Liquid Crystal Display (LCD), kurz LCD, basiert auf der Flüssigkristalltechnologie. Beim Entwerfen elektronischer Geräte benötigen wir ein kostengünstiges Gerät zur Anzeige von Informationen und der zweite ebenso wichtige Faktor ist die Verfügbarkeit vorgefertigter Bibliotheken für Arduino. Von allen auf dem Markt erhältlichen LCD-Displays wird am häufigsten das LCD 1602A verwendet, das ASCII-Zeichen in zwei Zeilen (16 Zeichen in einer Zeile) und jedes Zeichen in einer 5x7-Pixel-Matrix anzeigen kann. In diesem Artikel befassen wir uns mit den Grundlagen zum Anschluss eines Displays an Arduino.
Technische Spezifikationen
Versorgungsspannung: 5 V
Displaygröße: 2,6 Zoll
Anzeigetyp: 2 Zeilen x 16 Zeichen
Farbe der Hintergrundbeleuchtung: Blau
Charakterfarbe: Weiß
Abmessungen: 80 mm x 35 mm x 11 mm
Beschreibung anzeigen
LCD 1602A ist ein elektronisches Modul, das auf dem HD44780-Treiber von Hitachi basiert. Der LCD1602 verfügt über 16 Pins und kann im 4-Bit-Modus (unter Verwendung von nur 4 Datenleitungen) oder im 8-Bit-Modus (unter Verwendung aller 8 Datenleitungen) betrieben werden, oder es kann eine I2C-Schnittstelle verwendet werden. In diesem Artikel werde ich über die Verbindung im 4-Bit-Modus sprechen.
Kontaktbelegung:
VSS: „-“ Modul-Stromversorgung
VDD: „+“-Modul-Stromversorgung
VO: Kontrastkontrollstift
RS: Registerauswahl
RW: Schreib- oder Lesemodus auswählen (bei Verbindung mit Masse auf Schreibmodus einstellen)
E: Falltor
DB0-DB3: Schnittstellenbits
DB4-DB7: Schnittstellenbits
A: „+“ Hintergrundbeleuchtungsleistung
K: „-“ Hintergrundbeleuchtungsleistung
Auf der Vorderseite des Moduls befindet sich LCD Bildschirm und eine Gruppe von Kontakten.
Auf der Rückseite des Moduls befinden sich zwei Chips im „Droplet“-Design (ST7066U und ST7065S) und eine elektrische Verkabelung. Ich sehe keinen Sinn darin, einen Schaltplan zu zeichnen, ich erzähle Ihnen nur etwas über den Widerstand R8 (100). Ohm), der als Begrenzungswiderstand für die LED-Hintergrundbeleuchtung dient, sodass Sie 5V direkt an Pin A anschließen können. Etwas später werde ich einen Artikel schreiben, in dem ich Ihnen erzähle, wie Sie die Hintergrundbeleuchtung eines LCD-Displays mithilfe eines ändern können PWB und ein Transistor.
LCD 1602A mit Arduino verbinden (4-Bit-Modus)
Benötigte Teile:
Arduino UNO R3 x 1 Stk.
LCD-Display 1602A (2×16, 5V, Blau) x 1 Stk.
DuPont-Draht, 2,54 mm, 20 cm, F-F (Buchse - Buchse) x 1 Stk.
Potentiometer 10 kOhm x 1 Stk.
PLS-16-Stecker x 1 Stk.
Entwicklungsboard MB-102 x 1 Stk.
USB-Kabel 2,0 A-B x 1 Stk.
Verbindung:
Zum Anschließen verwenden wir ein Entwicklungsboard. Das Diagramm und die Tabelle zum Anschließen des LCD1602a an Arduino im 4-Bit-Modus sind in der folgenden Abbildung zu sehen.
Der Anschluss des Displays an das Steckbrett erfolgt über PLS-16-Pins (diese müssen an das Display angelötet werden). Installieren Sie das Anzeigemodul in der Steckplatine und verbinden Sie die Stromversorgung VDD (2. Pin) mit 5 V (Arduino) und VSS (1. Pin) mit GND (Arduino). Verbinden Sie dann RS (4. Pin) mit dem digitalen Pin 8 (Arduino). Erden Sie RW (5. Pin), indem Sie es mit GND (Arduino) verbinden, und verbinden Sie dann Pin E mit Pin 8 (Arduino). Für eine 4-Bit-Verbindung werden vier Pins benötigt (DB4 bis DB7). Verbinden Sie die Pins DB4 (11. Pin), DB5 (12. Pin), DB6 (13. Pin) und DB7 (14. Pin) mit den Arduino-Digitalpins 4, 5, 6 und 7. Ein 10K-Potentiometer dient zur Einstellung des Displaykontrasts, das Anschlussdiagramm für Das LCD-Display des 1602a ist unten abgebildet
Die Bibliothek ist bereits in der Arduino IDE enthalten und muss nicht installiert werden. Kopieren Sie diesen Beispielcode, fügen Sie ihn in das Arduino IDE-Programmfenster ein und laden Sie ihn in den Controller.
/* Der Test wurde durchgeführt am Arduino-IDE 1.6.11 Testdatum 20.09.2016 */ #enthalten
Die Tests wurden mit der Arduino IDE 1.6.11 durchgeführt Testdatum: 20.09.2016 #enthalten LiquidCrystal-LCD (8, 9, 4, 5, 6, 7); void setup() LCD. begin(16, 2); // Initialisiert LCD 16x2 Leere Schleife() LCD. print ("Hallo, Welt" ); // Text drucken LCD. drucken ("www.robotchip.ru" ); // Text drucken |
Programm herunterladen
Ein wenig über das Programm.
Um die Kommunikation zwischen dem Arduino und dem LCD-Display zu erleichtern, wird die integrierte Bibliothek in der Arduino IDE verwendet. LiquidCrystal.h « - was für LCD-Displays geschrieben ist HD44780 (Hitachi) Chipsatz (oder kompatible Chips). Diese Bibliothek kann sowohl LCD-Verbindungen im 4-Bit-Modus als auch im 8-Bit-Modus verarbeiten.
Diese Anleitung zeigt, wie man eine Verbindung zu Arduino herstellt und 16x2- und 20x4-LCD-Bildschirme verwendet.
Diese Bildschirme verfügen über eine integrierte Hintergrundbeleuchtung auf Basis einer Low-Power-LED und werden mit +5 V betrieben. Für den Anschluss dieser LCD-Bildschirme benötigen Sie 6 Pins. Sie können alle Pins Ihres Arduino verwenden!
Die Anweisungen basieren auf LCD-Bildschirmen von Adafruit – Blue&White 16x2, RGB 16x2 LCD und Blue&White 20x4, RGB 20x4. Wenn Sie einen LCD-Bildschirm eines anderen Herstellers verwenden, gibt es keine 100-prozentige Garantie dafür, dass er funktioniert (obwohl er in 99 % der Fälle funktioniert).
Zeichen- und Grafik-LCDs – was ist der Unterschied?
Es gibt eine Vielzahl unterschiedlicher LCD-Bildschirme. In diesem Artikel werden wir uns mit Zeichen-LCDs befassen. Bildschirme wie diese sind eine großartige Option für die Anzeige von Text. Sie können die Anzeige von Symbolen auch anpassen, die Größe dieser Symbole sollte jedoch 7 Pixel nicht überschreiten (sehr klein!).
Das Foto unten zeigt ein Beispiel dafür, wie ein 16-Zeichen-LCD-Monitor mit zwei Zeilen funktioniert:
Wenn Sie genau hinsehen, erkennen Sie kleine Rechtecke, in denen die Symbole angezeigt werden. Jedes Rechteck ist ein separates Pixelraster. Zum Vergleich ist unten ein grafischer LCD-Bildschirm dargestellt:
Eine grafische Flüssigkristallanzeige verfügt über ein großes Pixelraster (Zoll). in diesem Beispiel- 128x64). Sie können darauf Text anzeigen, es ist jedoch besser, Bilder anzuzeigen. Grafik-LCDs sind normalerweise größer und haben mehr Kontakte Um eine Verbindung herzustellen, ist die Verwendung etwas schwieriger als die Verwendung von Textnachrichten.
In diesem Artikel behandeln wir nur Text-/Zeichenbildschirme!
Verschiedene Modelle von LCD-Bildschirmen
Nachdem wir die Art der betrachteten Bildschirme eingegrenzt haben, schauen wir uns an, um welche Art von Bildschirmen es sich handelt.
Auch wenn sie nur zur Anzeige von Text verwendet werden, gibt es welche verschiedene Modelle und Formfaktoren: In der oberen linken Ecke befindet sich ein 20x4 LCD-Bildschirm mit weißem Text Blauer Hintergrund, oben rechts – 16x4 mit schwarzem Text auf grünem Hintergrund, unten links – 16x2 mit weißem Text auf blauem Hintergrund und 16x1 mit schwarzem Text auf grauem Hintergrund.
Die gute Nachricht ist, dass alle diese Bildschirme austauschbar sind. Wenn Sie eines davon konfiguriert haben, können Sie es durch ein anderes Modell ersetzen. Die Arduino-Skizze muss sich ein wenig ändern, aber der Anschluss ist derselbe!
In diesem Teil verwenden wir LCD-Bildschirme mit einer Schiene und 16 Pins zum Anschluss (siehe Foto oben). Es gibt auch ein LCD mit 2 Schienen mit 8 Kontakten zum Anschluss (in der Abbildung unten).
Schwieriger gestaltet sich der Anschluss des zweiten Modells an eine lötfreie Platine.
Anschließen eines LCD-Zeichenbildschirms an Arduino
Stromschienen montieren
Zusätzlich zum LCD-Bildschirm benötigen Sie zusätzliche Verkabelung. Erstens ein 10-kOhm-Potentiometer. Mit dem Potentiometer stellen wir den Kontrast des Displays ein. Jeder LCD-Bildschirm verfügt über unterschiedliche Kontrasteinstellungen, daher sind Anpassungen ein Muss. Zusätzlich benötigen Sie eine 0,1" Kontaktschiene.
Sollte die Schiene mit Kontakten zu lang sein, können Sie die überschüssigen Kontakte einfach abschneiden!
Sie müssen die Pins an das LCD-Display anlöten.
Seien Sie beim Löten äußerst vorsichtig, um Ihr Breadboard nicht zu beschädigen! Sie können zuerst den ersten und den 16. Kontakt „greifen“ und dann den Rest verlöten.
Strom und Beleuchtung
Erläuterungen |
|
|---|---|
 |
Wir kommen langsam zu einigen interessanten Dingen! Installieren Sie Ihr LCD auf dem Steckbrett. |
 |
Entwicklungs-Board Wir betreiben es über unseren Arduino. Verbinden Sie +5V mit der roten Schiene und Gnd mit der blauen Schiene. |
 |
Danach schließen wir die Hintergrundbeleuchtung unseres LCD-Bildschirms an. Verbinden Sie Pin 16 mit GND und Pin 15 mit +5V. Die meisten LCD-Bildschirme verfügen über Widerstände für die Hintergrundbeleuchtung. Wenn Ihr Modul keine Widerstände enthält, müssen Sie einen zwischen 5 V und Pin 15 hinzufügen. Um die Widerstandswerte zu berechnen, überprüfen Sie den maximalen Strom für die Stromversorgung der Hintergrundbeleuchtung und den ungefähren Wert des Spannungsabfalls aus dem Datenblatt. Subtrahieren Sie den Spannungsabfallwert von 5 V, dividieren Sie ihn dann durch die maximale Stromstärke und runden Sie ihn auf den nächsthöheren Standardwiderstandswert auf. Wenn der Spannungsabfall beispielsweise 3,5 V und der Strom 16 mA beträgt, wäre der Widerstandswert: (5 – 3,5)/0,016 = 93,75 Ohm oder 100 Ohm nach Rundung auf den Standardwert. Wenn Sie das Datenblatt nicht finden können, verwenden Sie einen 220-Ohm-Widerstand. Allerdings kann die Hintergrundbeleuchtung in diesem Fall recht blass sein. |
 |
Schließen Sie Ihren Arduino an die Stromversorgung an. Die Hintergrundbeleuchtung sollte aufleuchten. |
Einige günstige LCD-Bildschirme haben übrigens keine Hintergrundbeleuchtung!
Schaltung zur Kontrasteinstellung
Erläuterungen |
|
|---|---|
 |
Installieren Sie das Potentiometer. Auf dem Foto befindet es sich rechts von Pin 1. |
 |
Verbinden Sie eine Seite des Potentiometers mit +5V und die andere mit Gnd. Verbinden Sie den mittleren Kontakt des Potentiometers mit Pin 3 auf dem LCD. |
 |
Jetzt verbinden wir die Logik unseres Bildschirms – das ist ein von der Hintergrundbeleuchtung getrennter Stromkreis! Pin 1 geht an Gnd und Pin 2 geht an +5V. |
 |
Schalten Sie Ihr Arduino ein. Wenn Ihr LCD-Monitor über eine Hintergrundbeleuchtung verfügt, sollte diese aufleuchten. Drehen Sie den Potentiometerknopf, um das erste Pixelrechteck in der ersten Zeile anzuzeigen. |
Wenn alles funktioniert hat, herzlichen Glückwunsch. Das bedeutet, dass Logik, Beleuchtung und Kontrast funktionieren! Wenn es nicht funktioniert, fahren Sie nicht mit den nächsten Schritten in der Anleitung fort, bis Sie herausgefunden haben, was der Fehler ist!
Endgültige Verbindung
D0 bis D7, RS, EN und RW. D0-D7 sind die Pins, die die an das Display gesendeten Werte speichern. Der RS-Pin teilt dem Controller mit, ob wir Daten anzeigen (z. B. ein ASCII-Zeichen) oder ob es sich um ein Steuerbyte handelt (z. B. Ändern der Cursorposition). Der EN-Pin ist die Abkürzung für „Enable“ und mit diesem Pin teilen wir dem LCD mit, wann die Daten zum Lesen bereit sind. Der RW-Pin wird verwendet, um die Richtung festzulegen – wir möchten (normalerweise) Daten anzeigen oder (seltener verwendet) vom Display lesen.
Nicht alle dieser Pins müssen mit dem Arduino verbunden werden. Beispielsweise besteht keine Notwendigkeit, RW zu verwenden, wenn wir nur Daten auf dem Bildschirm anzeigen. Es reicht also aus, sie an den Gnd-Pin „hochzuziehen“. Darüber hinaus können Sie mit dem LCD-Bildschirm über 4 statt 8 Pins kommunizieren. Es stellt sich wahrscheinlich die natürliche Frage, in welchen Fällen 8 Pins verwendet werden? Dies wirkt sich höchstwahrscheinlich auf die Datenübertragungsgeschwindigkeit aus. Das heißt, durch die Verwendung von 8 statt 4 Kontakten können Sie die Geschwindigkeit des Informationsaustauschs um das Zweifache erhöhen. In diesem Fall ist die Geschwindigkeit nicht wichtig, daher verwenden wir 4 Pins, um das LCD mit dem Arduino zu verbinden.
Wir brauchen also 6 Pins: RS, EN, D7, D6, D5 und D4.
Um mit dem LCD-Bildschirm zu arbeiten, verwenden wir die LiquidCrystal-Bibliothek, die das Einrichten von Pins erheblich vereinfacht. Einer der Vorteile dieser Bibliothek besteht darin, dass Sie beliebige Pins auf dem Arduino verwenden können, um die LCD-Pins zu verbinden. Am Ende dieser Anleitung können Sie die Kontakte problemlos austauschen, wenn dies für Ihr Projekt von entscheidender Bedeutung ist.
Erläuterungen |
|
|---|---|
 |
Wie oben erwähnt, werden wir den RW-Pin nicht verwenden, also ziehen wir ihn auf Masse. Das ist Pin 5. |
 |
Dann verbinden wir RS – das ist Pin #4. Wir verwenden das braune Kabel, um es mit dem digitalen Pin Nr. 7 am Arduino zu verbinden. |
 |
Verwenden Sie ein weißes Kabel, um den EN-Pin (Pin Nr. 6) mit dem digitalen Pin Nr. 8 am Arduino zu verbinden. |
 |
Jetzt ist es Zeit für die Datenkontakte. DB7 ist Pin Nr. 14 auf dem LCD. Es ist mit einem orangefarbenen Kabel an Pin Nr. 12 des Arduino angeschlossen. |
 |
Es sind noch drei Datenpins übrig: DB6 (Pin Nr. 13 gelb), DB5 (Pin Nr. 12 grün) und DB4 (Pin Nr. 11 blau). Sie werden jeweils an die Pins Nr. 11, 10 und 9 des Arduino angeschlossen. |
 |
Als Ergebnis der Verbindung erhalten Sie etwas Ähnliches wie auf dem Foto links. |
Wir verwenden ein Zeichen-LCD
Es ist Zeit, die Skizze auf Arduino hochzuladen, um den LCD-Bildschirm zu steuern. Die LiquidCrystal-Bibliothek ist standardmäßig in der Arduino IDE installiert. Wir müssen also nur eines der Beispiele herunterladen und es ein wenig an die Pins anpassen, die wir zum Verbinden verwendet haben.
Öffnen Sie die Skizze Datei→Beispiele→LiquidCrystal→HelloWorld.
Wir aktualisieren Informationen zu Pins. Wir suchen folgende Zeile:
Flüssigkristall-LCD (12, 11, 5, 4, 3, 2);
Und ändern Sie es in:
Jetzt können Sie die Skizze kompilieren und auf den Arduino hochladen.
Passen Sie ggf. den Kontrast an
Selbstverständlich können Sie das LCD-Display in jeder beliebigen Größe verwenden. Das Foto unten zeigt beispielsweise die Funktionsweise eines 20x4 LCD.
Oder schwarzer Text auf grünem Hintergrund:
Einer der Vorteile von Bildschirmen mit schwarzem Text auf grünem Hintergrund ist die Möglichkeit, die Hintergrundbeleuchtung auszuschalten.
Lassen Sie uns wie viele Zeilen verwenden
Lassen Sie uns verstehen, wie der LCD-Bildschirm mit langen Nachrichten und mehreren Zeilen umgeht. Wenn Sie beispielsweise die folgende Zeile ändern:
lcd.print("Hallo, Welt!");
Zum nächsten:
lcd.print("Hallo Welt! Das ist eine lange, lange Nachricht");
Bei einem 16x2-LCD-Display wird nach dem 16. Zeichen alles abgeschnitten:
Aber das 20x4-LCD überträgt die nicht angezeigten Zeichen von der ersten bis zur dritten Zeile (die zweite Zeile wird bis zur vierten fortgesetzt). Es ist nicht sehr praktisch, aber in diesem Stadium müssen Sie sich damit abfinden. Wenn Sie also lange Zeichenfolgen anzeigen, zählen Sie die Zeichen, damit Sie die zulässige Länge nicht überschreiten.
LCD mit RGB-Hintergrundbeleuchtung
Diese Bildschirme funktionieren genauso wie normale Bildschirme, verfügen jedoch über drei LEDs (rot, grün, blau) für die Hintergrundbeleuchtung, sodass Sie verschiedene Farben der Hintergrundbeleuchtung verwenden können.
Nachdem Sie das LCD angeschlossen und gemäß den obigen Anweisungen überprüft haben, verbinden Sie die LEDs mit den analogen PWM-Pins Ihres Arduino Feinabstimmung Farben. Wenn Sie einen Arduino Uno verwenden, sollten noch drei freie PWM-Pins übrig sein. Verbinden Sie die rote LED (Pin 16 auf dem LCD) mit Digital 3, die grüne LED (Pin 17) mit Digital 5 und die blaue LED (Pin 18 auf dem LCD) mit Digital 6. Das LCD-Modul verfügt bereits über Widerstände Es ist nicht erforderlich, zusätzliche Geräte anzuschließen.
Laden Sie nun die folgende Skizze auf Ihr Arduino hoch.
// in die Bibliotheksskizze aufnehmen:
#enthalten
#enthalten
#define REDLITE 3
#define GREENLITE 5
#define BLUELITE 6
// Geben Sie die Anzahl der von uns verwendeten Kontakte an
// für die Datenübertragung
LiquidCrystal-LCD (7, 8, 9, 10, 11, 12);
// Helligkeit kann im Bereich 0 -> 255 verändert werden
int Helligkeit = 255;
// Anzahl der Spalten und Zeilen auf dem LCD festlegen:
lcd.begin(16, 2);
// Anzeige der Meldung auf dem LCD.
lcd.print("RGB 16x2 Display");
lcd.setCursor(0,1);
lcd.print("Mehrfarbiges LCD");
pinMode(REDLITE, OUTPUT);
pinMode(GREENLITE, OUTPUT);
pinMode(BLUELITE, OUTPUT);
Helligkeit = 100;
für (int i = 0; i< 255; i++) {
setBacklight(i, 0, 255-i);
für (int i = 0; i< 255; i++) {
setBacklight(255-i, i, 0);
für (int i = 0; i< 255; i++) {
setBacklight(0, 255-i, i);
void setBacklight(uint8_t r, uint8_t g, uint8_t b) (
// Stelle die rote LED auf – sie ist heller als die anderen!
r = Karte(r, 0, 255, 0, 100);
g = Karte(g, 0, 255, 0, 150);
r = map(r, 0, 255, 0, Helligkeit);
g = map(g, 0, 255, 0, Helligkeit);
b = map(b, 0, 255, 0, Helligkeit);
// gemeinsame Anode, also invertieren!
r = Karte(r, 0, 255, 255, 0);
g = Karte(g, 0, 255, 255, 0);
b = Karte(b, 0, 255, 255, 0);
Serial.print("R = "); Serial.print(r, DEC);
Serial.print(" G = "); Serial.print(g, DEC);
Serial.print(" B = "); Serial.println(b, DEC);
analogWrite(REDLITE, r);
analogWrite(GREENLITE, g);
analogWrite(BLUELITE, b);
Das Ergebnis dieser Skizze wird im Video unten gezeigt.
createChar-Befehl
Wahrscheinlich möchten Sie Sonderzeichen verwenden. Wenn Sie beispielsweise ein Projekt mit einem Temperatursensor (Thermoelement) entwerfen, ist das Symbol (°) hilfreich.
Dies kann mit dem Befehl createChar erreicht werden. Alternativ finden Sie vielleicht eine tolle Website, die die ganze Drecksarbeit der Erstellung neuer Symbole für Sie erledigt!
Hinterlassen Sie unten Ihre Kommentare, Fragen und teilen Sie Ihre persönlichen Erfahrungen. In Diskussionen entstehen oft neue Ideen und Projekte!
- Das FC-113-Modul basiert auf dem PCF8574T-Chip, einem 8-Bit-Schieberegister – einem Input-Output-„Expander“ für den seriellen I2C-Bus. In der Abbildung ist die Mikroschaltung mit DD1 bezeichnet.
- R1 ist ein Trimmwiderstand zum Einstellen des Kontrasts des LCD-Displays.
- Jumper J1 dient zum Einschalten der Display-Hintergrundbeleuchtung.
- Die Pins 1…16 werden verwendet, um das Modul mit den Pins des LCD-Displays zu verbinden.
- Die Kontaktpads A1...A3 werden benötigt, um die I2C-Adresse des Geräts zu ändern. Durch Anlöten der entsprechenden Jumper können Sie die Geräteadresse ändern. Die Tabelle zeigt die Zuordnung von Adressen und Jumpern: „0“ entspricht einem offenen Stromkreis, „1“ einem installierten Jumper. Standardmäßig sind alle 3 Jumper geöffnet und die Geräteadresse 0x27.
2 Anschlussplan für LCD-Display an Arduinoüber I2C-Protokoll
Der Anschluss des Moduls an Arduino erfolgt auf die für den I2C-Bus übliche Weise: Der SDA-Pin des Moduls ist mit dem analogen Port A4 verbunden, der SCL-Pin ist mit dem analogen Port A5 des Arduino verbunden. Das Modul wird mit +5 V von Arduino versorgt. Das Modul selbst wird über die Pins 1…16 mit den entsprechenden Pins 1…16 auf dem LCD-Display verbunden.
3 Bibliothek für die Arbeitüber I2C-Protokoll
Jetzt benötigen wir eine Bibliothek, um mit LCD über die I2C-Schnittstelle zu arbeiten. Sie können zum Beispiel diesen verwenden (Link in der Zeile „Beispielcode und Bibliothek herunterladen“). 
Heruntergeladenes Archiv LiquidCrystal_I2Cv1-1.rar in einen Ordner entpacken \Bibliotheken\, das sich im Arduino IDE-Verzeichnis befindet.
Die Bibliothek unterstützt eine Reihe von Standardfunktionen für LCD-Bildschirme:
| Funktion | Zweck |
|---|---|
| Flüssigkristall() | erstellt eine Variable vom Typ LiquidCrystal und akzeptiert Anzeigeverbindungsparameter (Pin-Nummern); |
| beginnen() | Initialisieren des LCD-Displays, Einstellen von Parametern (Anzahl der Zeilen und Zeichen); |
| klar() | Löschen des Bildschirms und Zurücksetzen des Cursors auf die Ausgangsposition; |
| heim() | Bringen Sie den Cursor zur Ausgangsposition zurück. |
| setCursor() | Setzen des Cursors auf eine bestimmte Position; |
| schreiben() | zeigt das Symbol auf dem LCD-Bildschirm an; |
| drucken() | zeigt Text auf dem LCD-Bildschirm an; |
| Mauszeiger() | zeigt den Cursor, d.h. Unterstreichung unter der Stelle des nächsten Zeichens; |
| noCursor() | verbirgt den Cursor; |
| blinken() | Cursor blinkt; |
| noBlink() | Blinken abbrechen; |
| kein Bildschirm() | Ausschalten des Displays und gleichzeitiges Speichern aller angezeigten Informationen; |
| Anzeige() | Einschalten des Displays und gleichzeitiges Speichern aller angezeigten Informationen; |
| scrollDisplayLeft() | Scrollen Sie den Anzeigeinhalt um eine Position nach links. |
| scrollDisplayRight() | den Anzeigeinhalt um eine Position nach rechts scrollen; |
| Auto Scroll() | Autoscroll aktivieren; |
| noAutoscroll() | Autoscroll deaktivieren; |
| links nach rechts() | legt die Textrichtung von links nach rechts fest; |
| rechts nach links() | Textrichtung von rechts nach links; |
| createChar() | Erstellt einen benutzerdefinierten Charakter für den LCD-Bildschirm. |
4 Skizze zur Textausgabe zum LCD-Bildschirm über I2C-Bus
Öffnen wir das Beispiel: Dateibeispiele LiquidCrystal_I2C CustomChars und wir werden es ein wenig überarbeiten. Wir zeigen eine Meldung an, an deren Ende ein blinkendes Symbol erscheint. Die Kommentare zum Code kommentieren alle Nuancen der Skizze.
#enthalten
Übrigens, die vom Befehl geschriebenen Zeichen lcd.createChar();, bleiben auch nach dem Ausschalten im Anzeigespeicher, weil geschrieben, um ROM 1602 anzuzeigen.
5 Erstellen Sie Ihre eigenen Symbole für LCD-Display
Schauen wir uns die Frage der Erstellung eigener Symbole für LCD-Bildschirme genauer an. Jedes Zeichen auf dem Bildschirm besteht aus 35 Punkten: 5 breit und 7 hoch (+1 Reservelinie zum Unterstreichen). In Zeile 6 der obigen Skizze definieren wir ein Array aus 7 Zahlen: (0x0, 0xa, 0x1f, 0x1f, 0xe, 0x4, 0x0). Konvertieren Sie Hexadezimalzahlen in Binärzahlen: {00000, 01010, 11111, 11111, 01110, 00100, 00000} . Diese Zahlen sind nichts anderes als Bitmasken für jede der 7 Zeilen des Symbols, wobei „0“ einen hellen Punkt und „1“ einen dunklen Punkt bezeichnet. Beispielsweise erscheint auf dem Bildschirm ein als Bitmaske angegebenes Herzsymbol, wie in der Abbildung dargestellt.
6 Steuerung des LCD-Bildschirmsüber I2C-Bus
Laden wir die Skizze auf Arduino hoch. Auf dem Bildschirm erscheint die von uns angegebene Aufschrift mit einem blinkenden Cursor am Ende.
7 Was dahintersteckt I2C-Bus
Schauen wir uns als Bonus das Zeitdiagramm für die Anzeige der lateinischen Zeichen „A“, „B“ und „C“ auf dem LCD-Display an. Diese Zeichen werden im Display-ROM gespeichert und auf dem Bildschirm angezeigt, indem einfach ihre Adressen an das Display übertragen werden. Das Diagramm wird von den RS-, RW-, E-, D4-, D5-, D6- und D7-Pins des Displays übernommen, d. h. bereits nach dem FC-113 „I2C Parallel Bus“ Konverter. Wir können sagen, dass wir etwas tiefer in die Hardware eintauchen.
Zeitdiagramm der Ausgabe der lateinischen Zeichen „A“, „B“ und „C“ auf dem LCD-Display 1602 Das Diagramm zeigt, dass die Zeichen, die sich im Anzeige-ROM befinden (siehe S. 11 des Datenblatts, Link unten), in zwei Halbbytes übertragen werden, von denen das erste die Tabellenspaltennummer und das zweite die Zeilennummer bestimmt. In diesem Fall werden die Daten am Rand des Signals auf der Leitung „zwischengespeichert“. E(Aktivieren) und die Zeile R.S.(Registerauswahl) befindet sich im logischen Eins-Zustand, was bedeutet, dass Daten übertragen werden. Ein niedriger Zustand auf der RS-Leitung bedeutet, dass Anweisungen gesendet werden, was wir sehen, bevor jedes Zeichen übertragen wird. In diesem Fall wird der Wagenrücklauf-Befehlscode an die Position (0, 0) des LCD-Displays übertragen, die ebenfalls durch Studium ermittelt werden kann Technische Beschreibung Anzeige.
Und noch ein Beispiel. Dieses Zeitdiagramm zeigt die Ausgabe des Herzsymbols auf dem LCD-Display.
Nochmals die ersten beiden Impulse Aktivieren Anweisungen befolgen Heim()(0000 0010 2) - Bringen Sie den Schlitten in die Position (0; 0) zurück, und die zweiten beiden - Ausgabe des in Speicherzelle 3 10 (0000 0011 2) gespeicherten „Herz“-Symbols (Anweisung) an das LCD-Display lcd.createChar(3, Herz); skizzieren).
In dieser Lektion sprechen wir über die Charaktersynthese von Flüssigkristallindikatoren, deren Anschluss an das Arduino-Board und die Steuerung der Indikatoren mithilfe der Bibliotheken LiquidCrystal und LiquidCrystalRus.
LED-Siebensegmentanzeigen, obwohl sie die günstigste Anzeigeoption sind elektronische Geräte, aber ihre Verwendung wird durch zwei wesentliche Nachteile eingeschränkt.
- Es ist praktisch schwierig, mehr als 8-stellige LED-Anzeigen an einen Mikrocontroller anzuschließen. Es sind eine große Anzahl von Pins, erhebliche Anzeigeströme, komplexe Schalter, eine niedrige Regenerationsfrequenz usw. erforderlich.
- Es ist nicht möglich, symbolische Informationen auf Sieben-Segment-Indikatoren anzuzeigen.
Zum Rückzug Textinformationen oder Zahlen mit mehr als 4 Ziffern, ist es viel praktischer, Flüssigkristallanzeigen (Anzeigen) zu verwenden, die Zeichen synthetisieren. Zu ihren Vorteilen gehören:
- praktische Schnittstelle zum Anschluss an Mikrocontroller;
- Energieeffizient;
- niedrige Versorgungsspannung;
- Haltbarkeit.
Auf dem Markt gibt es eine Vielzahl unterschiedlicher Flüssigkristallanzeigen (LCD) verschiedener Hersteller. Fast alle ähneln sich in Parametern, Schnittstellensignalen und Steuerbefehlen. Derzeit sind die am häufigsten verwendeten LCD-Anzeigen auf dem russischen Markt Geräte des Herstellers Winstar, Taiwan. Ich werde mich auf die Indikatoren dieses Unternehmens beziehen. Die Informationen sind aber durchaus auch auf zeichenbasierte LCD-Displays anderer Hersteller anwendbar.
Allgemeine Informationen.
Zeichensynthetisierende oder symbolische Indikatoren zeigen Informationen in Form von Zeichen einer bestimmten Kapazität an. Eine Vertrautheit zeigt einen Charakter. Die Anzahl bekannter Orte bestimmt die Ziffernkapazität des Indikators. Informationen zu Indikatoren können in mehreren Zeilen angezeigt werden, daher werden bei Indikatoren dieser Art immer die Anzahl der Zeichen pro Zeile und die Anzahl der Zeilen angegeben.
Informationen werden auf einer Flüssigkristallmatrix mit angezeigt LED-Hintergrundbeleuchtung. Die Hintergrundbeleuchtung ist in verschiedenen Farben erhältlich, wodurch monochrome Textinformationen deutlich zum Leben erweckt werden.
Zur Steuerung der Flüssigkristallmatrix und zur Organisation der Anzeigeschnittstelle werden der integrierte HD44780-Controller oder seine vollständigen Analoga verwendet. Dieser Controller bestimmt die Signale der Anzeigeschnittstelle und Steuerbefehle.
Der HD44780 ist zum De-facto-Standard für Flüssigkristallanzeigen (LCD) geworden. Technische Dokumentationüber HD44780-Controller PDF-Format Sie können es unter diesem Link ansehen -. Vielleicht gefällt jemandem die Dokumentation eines der Analoga dieses Controllers – SPLC780D. Link im PDF-Format - .
Zeichen-LCD Winstar-Indikatoren.
Ich kenne die folgenden Optionen für LCD-Anzeigen dieser Firma.
| Indikatortyp | Anzeigeformat, Zeichen x Zeilen | Abmessungen, mm | Abmessungen der sichtbaren Fläche, mm | Link zur Dokumentation, PDF-Format |
| WH0802A1 | 8 x 2 | 58 x 32 | 38 x 16 | |
| WH1202A | 12 x 2 | 55,7 x 32 | 46 x 14,5 | |
| WH1601A | 16 x 1 | 80 x 36 | 66 x 16 | |
| WH1601B | 16 x 1 | 85 x 28 | 66 x 16 | |
| WH1601L | 16 x 1 | 122 x 33 | 99 x 13 | |
| WH1602A | 16 x 2 | 84 x 44 | 66 x 16 | |
| WH1602B | 16 x 2 | 80 x 36 | 66 x 16 | |
| WH1602C | 16 x 2 | 80 x 36 | 66 x 16 | |
| WH1602D | 16 x 2 | 85 x 30 | 66 x 16 | |
| WH1602J | 16 x 2 | 80 x 36 | 66 x 16 | |
| WH1602L1 | 16 x 2 | 122 x 44 | 99 x 24 | |
| WH1602M | 16 x 2 | 85 x 32,6 | 66 x 16 | |
| WH1602O | 16 x 2 | 85 x 25,2 | 66 x 16 | |
| WH1602P | 16 x 2 | 85 x 25,2 | 66 x 16 | |
| WH1602S | 16 x 2 | 59 x 29,3 | 52 x 15 | |
| WH1602T | 16 x 2 | 65,4 x 28,2 | 54,8 x 19 | |
| WH1602W | 16 x 2 | 80 x 36 | 66 x 16 | |
| WH1602V2 | 16 x 2 | 66,7 x 23,3 | 61 x 15,9 | |
| WH1604A | 16 x 4 | 87 x 60 | 62 x 26 | |
| WH1604B | 16 x 4 | 70,6 x 60 | 60 x 32,6 | |
| WH2002A | 20 x 2 | 116 x 37 | 85 x 18,6 | |
| WH2002D | 20 x 2 | 89 x 21,5 | 75 x 15 | |
| WH2002L | 20 x 2 | 180 x 40 | 149 x 23 | |
| WH2002M | 20 x 2 | 146 x 43 | 123 x 23 | |
| WH2004A | 20 x 4 | 98 x 60 | 77 x 25,2 | |
| WH2004B | 20 x 4 | 98 x 60 | 77 x 25,2 | |
| WH2004D | 20 x 4 | 77 x 47 | 60 x 22 | |
| WH2004G | 20 x 4 | 87 x 58 | 74,4 x 24,8 | |
| WH2004H | 20 x 4 | 87 x 58 | 74,4 x 24,8 | |
| WH2004L | 20 x 4 | 146 x 62,5 | 123,5 x 43 | |
| WH2402A | 24 x 2 | 118 x 36 | 94,5 x 16 | |
| WH4002A | 40 x 2 | 182 x 33,5 | 154,4 x 16,5 | |
| WH4004A | 40 x 4 | 190 x 54 | 147 x 29,5 |
Anschließen einer LCD-Anzeige an einen Mikrocontroller.
Anschlusspläne, Zeitdiagramme, Signalparameter, Steuerbefehle und Symbolcodes werden ausführlich in der Dokumentation zum HD44780-Controller beschrieben. Ich werde nur die notwendigsten Daten zum Anschluss von Indikatoren an Mikrocontroller bereitstellen.
Typischerweise haben LCD-Anzeigen 16 Pins.
| PIN Nummer | Signal | I - Eingang O - Ausgang | Signalzweck |
| 1 | Vss | - | Masse (gemeinsam) |
| 2 | Vdd | - | Stromversorgung +5V |
| 3 | Vo | - | Kontrastkontrolle des Displays. Eingang zum Anschluss des mittleren Ausgangs des Spannungsteilers + 5 V. Sie können einen Trimmwiderstand mit einem Widerstand von 10-20 kOhm verwenden. |
| 4 | R.S. | ICH | Registerauswahl: 0 – Befehlsregister; 1 – Datenregister. Ein niedriger Signalpegel bedeutet, dass ein Befehl auf dem Datenbus generiert wurde, ein hoher Pegel bedeutet, dass ein Befehl auf dem Datenbus generiert wurde. |
| 5 | R/W | ICH | Richtung der Datenübertragung: 0 – Aufnahme; 1 – Lesen. In vielen Anwendungen wird die Lesefunktion nicht verwendet, daher ist das Signal häufig mit Masse verbunden. |
| 6 | E | ICH | Busbetriebs-Strobe (an negativer Flanke). |
| 7 | DB0 | E/A | Niedrigwertige Bits des Acht-Bit-Modus. Wird nicht mit einer Vier-Bit-Schnittstelle verwendet. |
| 8 | DB1 | E/A | |
| 9 | DB2 | E/A | |
| 10 | DB3 | E/A | |
| 11 | DB4 | E/A | Die höchstwertigen Bits des Acht-Bit-Modus bzw. die Datenbits der Vier-Bit-Schnittstelle. |
| 12 | DB5 | E/A | |
| 13 | DB6 | E/A | |
| 14 | DB7 | E/A | |
| 15 | A | - | Stromanode der Hintergrundbeleuchtung (+). |
| 16 | K | - | Leistungskathode der Hintergrundbeleuchtung (-). Der Strom muss begrenzt werden. |
Die Pin-Nummer (erste Spalte) gilt für die häufigste Option. Es ist besser, dies zu überprüfen, indem Sie die Dokumentation für Ihren Indikatortyp aus der Tabelle im vorherigen Abschnitt herunterladen.
Zeichen-LCD-Displays unterstützen zwei Anschlussmöglichkeiten an den Mikrocontroller:
- Verwendung eines 8-Bit-Datenbusses. Alle Bussignale DB0-DB7 sind verbunden. In einem Austauschzyklus wird ein Byte an Informationen übertragen.
- Verwendung eines 4-Bit-Datenbusses. Nur die 4 höchstwertigen Bits DB4-DB7 sind verbunden. Die Informationsübertragung erfolgt vier Bits pro Bustaktzyklus.
Die erste Option ermöglicht die Datenübertragung zum Display von höhere Geschwindigkeit. Der zweite benötigt 4 Pins weniger, um den Indikator anzuschließen. Zweifellos ist es wichtiger, die Anzahl der Anschlusspins zu reduzieren, als die Austauschgeschwindigkeit zu erhöhen. Darüber hinaus sind LCD-Anzeiger eher langsame Geräte mit einer Regenerationszykluszeit von 10–20 ms.
Anschließen eines LCD-Zeichendisplays an die Arduino-Platine.
Ich werde den WH2004A-Indikator (4 Zeilen mit je 20 Zeichen) im Vier-Bit-Austauschmodus anschließen Arduino-Board UNO R3. Die Dokumentation für das LCD-Display WH2004 können Sie unter diesem Link einsehen.
Das Diagramm sieht so aus.
Die Widerstände R2 und R3 bestimmen den Kontrast des Indikators. Sie können einen Trimmwiderstand anschließen und die gewünschte Bildschärfe einstellen. Ich verwende oft WH2004-Anzeigen und wähle in meinen Schaltkreisen diese Widerstandswerte.
Ich habe die LEDs der Anzeige-Hintergrundbeleuchtung über den Widerstand R1 (30 Ohm) an eine 5-V-Stromquelle angeschlossen. Damit stelle ich den Strom auf ca. 25 mA ein. Düster, aber leuchtend. Man kann im Dunkeln gut sehen. Obwohl WH2004-Anzeigen einen Hintergrundbeleuchtungsstrom von bis zu 580 mA ermöglichen.
Bibliothek zur Steuerung von LCD-Anzeigen im Arduino LiquidCrystal-System.
Es gibt eine Standardbibliothek zur Steuerung von LCD-Anzeigen basierend auf dem HD44780-Controller. Ich werde ihre Methoden im Detail beschreiben.
Flüssigkristall(…)
Klassenkonstruktor. Kann eine unterschiedliche Anzahl von Argumenten haben.
- LiquidCristal(rs, en, d4, d5, d6, d7) – Vier-Bit-Schnittstelle, das RW-Signal wird nicht verwendet (mit Masse verbunden).
- LiquidCristal(rs,rw, en, d4, d5, d6, d7) – Vier-Bit-Schnittstelle, RW-Signal wird verwendet.
- LiquidCristal(rs, en, d0, d1, d2, d3, d4, d5, d6, d7) – Acht-Bit-Schnittstelle, das RW-Signal wird nicht verwendet (mit Masse verbunden).
- LiquidCristal(rs, rw, en, d0, d1, d2, d3, d4, d5, d6, d7) – Acht-Bit-Schnittstelle, RW-Signal wird verwendet.
Argumente:
- rs – RS-Signal-Pin-Nummer;
- rw – Nummer des RW-Signalausgangs;
- en – Signalausgangsnummer E;
- d0, d1, d2, d3, d4, d5, d6, d7 – Datenbus-Pin-Nummern.
LiquidCrystal disp(6, 7, 2, 3, 4, 5);
void begin(cols, rows)
Initialisiert die Indikatorschnittstelle. Legt die Indikatordimension fest. Die Methode muss zuerst aufgerufen werden, bevor andere Klassenfunktionen verwendet werden.
Argumente:
- cols – Anzahl der Zeichen in der Zeile;
- Reihen – Anzahl der Reihen.
disp.begin(20, 4); // Wir verwenden ein Display – 4 Zeilen mit 20 Zeichen
void klar()
Löschen Sie den Bildschirm und platzieren Sie den Cursor in der oberen linken Ecke.
disp.clear(); // Anzeige zurücksetzen
void home()
Platzieren Sie den Cursor in der oberen linken Ecke.
disp.home(); // zum Anfang des Bildschirms
void setCursor(col, row)
Platziert den Cursor an der angegebenen Position.
- col – X-Koordinate, Nummerierung ab 0;
- Zeile – Y-Koordinate, Nummerierung ab 0.
setCursor(0,1); // Cursor an den Anfang der zweiten Zeile setzen
Byte schreiben (Daten)
Zeigt ein Symbol auf dem Bildschirm an. Gibt die Anzahl der übertragenen Bytes zurück.
Die folgende Skizze zeigt Daten vom seriellen Port. Daten können vom Arduino IDE-Port-Monitor übertragen werden.
// Datenausgabe über serielle Schnittstelle auf LCD-Anzeige
#enthalten
char-Daten;
void setup()
{
Serial.begin(9600); // Initialisieren Sie die serielle Schnittstelle
disp.begin(20, 4); //
}
Leere Schleife()
{
if (Serial.available()) ( // wenn es Daten gibt
data= Serial.read(); // das Symbol lesen
if((data != 0xd) && (data != 0xa)) ( // Zeilenvorschub
disp.write(data); // das Symbol auf dem Bildschirm anzeigen
}
}
}
Ich habe einen großen Indikator – 4 Zeilen mit 20 Zeichen. Es enthält zwei HD44780-Controller. Daher füllen nacheinander übertragene Zeichen zuerst die erste Zeile, dann die dritte, dann die zweite und vierte. Diese. durch die Linie. Diese Eigenschaft muss bei bestimmten Arten von Indikatoren berücksichtigt werden. Die Dokumentation für jeden LCD-Anzeiger gibt die Zeichenadressierungssequenz an.
Bytedruck (Daten)
Zeigt Text auf dem Bildschirm an. Gibt die Anzahl der übertragenen Bytes zurück.
Argumente:
Daten – Daten, die auf dem Bildschirm angezeigt werden sollen. Kann die Typen char, byte, int, long, string haben.
Möglicherweise gibt es ein zweites, optionales Argument.
Byte print(Daten, BASE)
- BASE – gibt das Zahlensystem an:
- BIN – binär;
- DEC – dezimal;
- OCT – Oktal:
- HEX – hexadezimal.
Ein Beispiel für ein Programm, das eine Textzeichenfolge auf dem Display ausgibt.
// Anzeige einer Textzeile auf der LCD-Anzeige
#enthalten
LiquidCrystal disp(6, 7, 2, 3, 4, 5); // ein Objekt erstellen
void setup()
{
disp.begin(20, 4); // Initialisieren Sie die Anzeige mit 4 Zeilen mit 20 Zeichen
disp.print("Testzeichenfolge");
}
Leere Schleife()
{ }
Leerer Cursor()
Aktiviert den Cursor-Anzeigemodus. Die Position, an der das nächste Zeichen ausgegeben wird, ist unterstrichen.
disp.cursor(); // Cursoranzeige zulassen
void noCursor()
Deaktiviert die Anzeige des Cursors.
disp.noCursor(); // Deaktivieren Sie die Cursoranzeige
void blink()
Aktiviert den blinkenden Cursormodus. Wird in Verbindung mit der Funktion „cursor()“ verwendet. Das Ergebnis hängt davon ab spezifisches Modell Indikator.
disp.blink(); // blinkenden Cursor zulassen
void noBlink()
Deaktiviert den blinkenden Cursormodus.
disp.noBlink(); // Deaktivieren Sie den blinkenden Cursor
void display()
Schaltet den Bildschirm ein, nachdem er durch noDisplay() ausgeschaltet wurde. Auf dem Bildschirm werden die Informationen angezeigt, die vor dem Herunterfahren vorhanden waren.
display.display(); // Schalten Sie die Anzeige ein
void noDisplay()
Schaltet den Bildschirm aus. Die Informationen werden im Speicher abgelegt und erscheinen, wenn das Display eingeschaltet wird.
disp.noDisplay(); // den Bildschirm ausschalten
void scrollDisplayLeft()
Scrollt den Anzeigeinhalt um ein Zeichen nach links.
disp. scrollDisplayLeft(); // alles nach links verschieben
void scrollDisplayRight()
Scrollt den Anzeigeinhalt um ein Zeichen nach rechts.
disp. scrollDisplayRight(); // alles nach rechts verschieben
void autoscroll()
Aktivieren Sie den automatischen Text-Scroll-Modus. Während jedes Zeichen angezeigt wird, verschiebt sich der gesamte Text auf dem Bildschirm um ein Zeichen. Die Funktionen leftToRight() und rightToLeft() bestimmen, in welche Richtung die Informationen verschoben werden.
disp. Auto Scroll())(; // Automatisches Scrollen aktivieren
void noAutoscroll()
Deaktivieren Sie das automatische Scrollen von Text.
disp. noAutoscroll())(; // Deaktivieren Sie das automatische Scrollen
void leftToRight()
Legt den Testausgabemodus von links nach rechts fest. Neue Symbole werden rechts neben den vorherigen angezeigt.
links nach rechts(); // Links-nach-rechts-Modus
void rightToLeft()
Legt den Testausgabemodus von rechts nach links fest. Neue Symbole werden links von den vorherigen angezeigt.
rechts nach links(); // Rechts-nach-Links-Modus
void createChar(num, data)
Methode zum Erstellen eines benutzerdefinierten Symbols. Der Controller ermöglicht die Erstellung von bis zu 8 Zeichen (0...7) mit 5x8 Pixeln. Das Symbolbild wird durch ein 8-Byte-Array angegeben. Die niedrigstwertigen 5 Bits jedes Bytes bestimmen den Zustand der Pixel in der Zeile.
Um ein benutzerdefiniertes Zeichen auszugeben, können Sie die Funktion write() mit der Zeichennummer verwenden.
// Erstellen eines benutzerdefinierten Symbols
#enthalten
LiquidCrystal disp(6, 7, 2, 3, 4, 5); // ein Objekt erstellen
Byte-Lächeln = (
B00000000,
B00010001,
B00000000,
B00000000,
B00010001,
B00001110,
B00000000,
B00000000
};
void setup()
{
disp.createChar(0, smile); // ein Symbol erstellen
disp.begin(20, 4); // Initialisieren Sie die Anzeige mit 4 Zeilen mit 20 Zeichen
disp.print("Smile");
disp.write(byte(0)); // das Symbol drucken
}
Leere Schleife()
{ }
Hier ist ein Beispiel für ein Programm, das das russische Alphabet anzeigt.
// Ausgabe des russischen Alphabets
#enthalten
LiquidCrystalRus disp(6, 7, 2, 3, 4, 5); // ein Objekt erstellen
void setup()
{
disp.begin(20, 4); // Initialisieren Sie die Anzeige mit 4 Zeilen mit 20 Zeichen
disp.print("abvgdeezhziyklmnoprst");
disp.print("ABVGDEYOZHIYKLMNOPRST");
disp.print("ughhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh");
Anweisungen
Die Funktionsweise des Ultraschall-Entfernungsmessers HC-SR04 basiert auf dem Prinzip der Echoortung. Es sendet Schallimpulse in den Weltraum und empfängt ein von einem Hindernis reflektiertes Signal. Die Entfernung zum Objekt wird durch die Ausbreitungszeit der Schallwelle zum Hindernis und zurück bestimmt.
Die Schallwelle wird durch Anlegen eines positiven Impulses von mindestens 10 Mikrosekunden Dauer an den TRIG-Zweig des Entfernungsmessers ausgelöst. Sobald der Impuls endet, sendet der Entfernungsmesser ein Paket von Schallimpulsen mit einer Frequenz von 40 kHz in den Raum vor ihm. Gleichzeitig wird der Algorithmus zur Bestimmung der Verzögerungszeit des reflektierten Signals gestartet und eine logische Einheit erscheint auf dem ECHO-Entfernungsmesserbein. Sobald der Sensor das reflektierte Signal erkennt, erscheint am ECHO-Pin eine logische Null. Die Dauer dieses Signals („Echoverzögerung“ in der Abbildung) bestimmt die Entfernung zum Objekt.
Der Entfernungsmessbereich des Entfernungsmessers HC-SR04 beträgt bis zu 4 Meter bei einer Auflösung von 0,3 cm. Der Betrachtungswinkel beträgt 30 Grad, der effektive Winkel beträgt 15 Grad. Der Stromverbrauch im Standby-Modus beträgt 2 mA, im Betrieb 15 mA.
Der Ultraschall-Entfernungsmesser wird mit einer Spannung von +5 V betrieben. Die anderen beiden Pins sind mit beliebigen digitalen Arduino-Ports verbunden; wir verbinden mit 11 und 12.
Schreiben wir nun einen Sketch, der den Abstand zum Hindernis ermittelt und an die serielle Schnittstelle ausgibt. Zuerst legen wir die Nummern der TRIG- und ECHO-Pins fest – das sind die Pins 12 und 11. Dann deklarieren wir den Trigger als Output und das Echo als Input. Initialisieren Sie die serielle Schnittstelle mit 9600 Baud. Jede Wiederholung des Zyklus Schleife() Wir lesen die Entfernung ab und geben sie an den Hafen aus.
Funktion getEchoTiming() erzeugt einen Triggerimpuls. Es erzeugt lediglich einen Strom von 10 Mikrosekunden, einen Impuls, der den Entfernungsmesser auslöst, ein Schallpaket in den Weltraum auszusenden. Als nächstes merkt es sich die Zeit vom Beginn der Übertragung der Schallwelle bis zum Eintreffen des Echos.
Funktion getDistance() berechnet die Entfernung zum Objekt. Aus dem Physikkurs in der Schule erinnern wir uns, dass die Entfernung gleich der Geschwindigkeit mal der Zeit ist: S = V*t. Die Schallgeschwindigkeit in der Luft beträgt 340 m/s, wir kennen die Zeit in Mikrosekunden, das ist „Duratuion“. Um die Zeit in Sekunden zu erhalten, dividieren Sie durch 1.000.000. Da Schall die doppelte Distanz zurücklegt – zum Objekt und zurück – müssen Sie die Distanz halbieren. Es stellt sich also heraus, dass die Entfernung zum Objekt S = 34.000 cm/Sek. * Dauer / 1.000.000 Sek. / 2 = 1,7 cm/Sek. / 100 beträgt, was wir in der Skizze geschrieben haben. Der Mikrocontroller führt die Multiplikationsoperation schneller aus als die Division, daher habe ich „/ 100“ durch das Äquivalent „* 0,01“ ersetzt.
Außerdem wurden viele Bibliotheken für die Arbeit mit Ultraschall-Entfernungsmessern geschrieben. Zum Beispiel dieses hier: http://robocraft.ru/files/sensors/Ultrasonic/HC-SR04/ultrasonic-HC-SR04.zip. Die Installation der Bibliothek erfolgt standardmäßig: Herunterladen, in ein Verzeichnis entpacken Bibliotheken, das sich im Arduino IDE-Ordner befindet. Danach kann die Bibliothek genutzt werden.
Nachdem wir die Bibliothek installiert haben, schreiben wir einen neuen Sketch. Das Ergebnis seiner Operation ist das gleiche: Der Monitor der seriellen Schnittstelle zeigt die Entfernung zum Objekt in Zentimetern an. Wenn Sie in einer Skizze schreiben float dist_cm = ultraschall.Ranging(INC);, der Abstand wird in Zoll angezeigt.
Also haben wir den Ultraschall-Entfernungsmesser HC-SR04 an Arduino angeschlossen und in zwei Teilen Daten von ihm empfangen verschiedene Wege: mit und ohne Verwendung einer speziellen Bibliothek.
Der Vorteil der Verwendung der Bibliothek besteht darin, dass die Codemenge erheblich reduziert und die Lesbarkeit des Programms verbessert wird; Sie müssen sich nicht in die Feinheiten des Geräts vertiefen und können es sofort verwenden. Doch darin liegt ein Nachteil: Man versteht schlechter, wie das Gerät funktioniert und welche Prozesse darin ablaufen. Welche Methode Sie verwenden, liegt in jedem Fall bei Ihnen.
