Arduino UNO Q - LCD 20x4
Diese Anleitung zeigt Ihnen, wie Sie ein LCD 20x4 I2C-Display mit Arduino UNO Q verwenden — von grundlegendem Text bis zu benutzerdefinierten Zeichen, Scrollen und Telegram-Fernsteuerung.
- Verbindung eines LCD 20x4 I2C mit Arduino UNO Q
- Anzeige von "Hello World" Text auf allen 4 Reihen
- Anzeige von Text, Ganzzahlen, Dezimalzahlen und Hexadezimalzahlen auf dem LCD
- Erstellung und Anzeige benutzerdefinierter Zeichen auf dem LCD
- Scrollen von Text über das LCD-Display
- Steuerung der LCD-Beleuchtung
- Verwendung von Cursor- und Blinkmodi
- Remote-Steuerung des LCD von Linux aus über Bridge-Programmierung
- Remote-Steuerung des LCD von Telegram aus über Bridge-Programmierung
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Kaufhinweis: Eine weitere Möglichkeit ist, das LCD I2C-Display zu erstellen, indem Sie LCD 1602 Display und PCF8574 I2C Adapter Module kombinieren.
Über LCD I2C 20x4
Das LCD 20x4 I2C hat 20 Spalten und 4 Reihen — doppelt so viele Reihen wie das 16x2, was es für Dashboards, Menüs und mehrzeilige Statusanzeigen nützlich macht. Wie das 16x2 verwendet es ein I2C-Backpack für eine einfache 4-adrige Verbindung.
Das LCD-Pinout
Das LCD I2C hat vier Pins:
- GND — mit GND verbinden
- VCC — mit 5V verbinden
- SDA — I2C-Datensignal
- SCL — I2C-Taktsignal
LCD-Koordinate
Das LCD I2C 20x4 hat 20 Spalten und 4 Reihen, nummeriert ab 0.
Verdrahtungsdiagramm
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
| LCD I2C-Pin | Arduino UNO Q-Pin |
|---|---|
| GND | GND |
| VCC | 5V |
| SDA | SDA |
| SCL | SCL |
※ Notiz:
Die I2C-Adresse kann je nach Hersteller unterschiedlich sein. Wir verwenden 0x27 wie von DIYables angegeben. Wenn 0x27 nicht funktioniert, versuchen Sie 0x3F.
Programmierung für LCD I2C 20x4
Die DIYables_LCD_I2C Bibliothek funktioniert für 16x2 und 20x4 — ändern Sie einfach die Spalten- und Zeilenzahl.
- Erstellen Sie das LCD-Objekt für 20x4:
DIYables_LCD_I2C lcd(0x27, 20, 4); // I2C address 0x27, 20 columns, 4 rows
- Initialisierung in setup():
lcd.init();
lcd.backlight();
- Verschieben Sie den Cursor und drucken Sie (Reihen 0–3):
lcd.setCursor(0, 0); // column 0, row 0
lcd.print("Row 0 text here");
lcd.setCursor(0, 3); // column 0, row 3
lcd.print("Row 3 text here");
Weitere Funktionen wie benutzerdefinierte Zeichen und Fehlerbehebungstipps finden Sie im LCD I2C-Anleitung.
Arduino UNO Q Code — Hello World auf LCD 20x4
Der Arduino UNO Q hat zwei Prozessoren: die STM32 MCU (verwaltet Echtzeitsteuerung der Hardware) und die Qualcomm MPU (läuft Debian Linux). In diesem Abschnitt wird nur die STM32 MCU programmiert — die Linux-Seite bleibt untätig. Ein späterer Abschnitt zeigt, wie beide Prozessoren zusammenarbeiten.
Der Sketch unten zeigt Text auf allen vier Reihen des LCD an.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-lcd-20x4
*/
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 20, 4); // I2C address 0x27, 20 columns, 4 rows
void setup() {
Monitor.begin(9600);
lcd.init(); // Initialize the LCD
lcd.backlight(); // Turn on the backlight
lcd.setCursor(0, 0);
lcd.print("Hello, World!");
lcd.setCursor(0, 1);
lcd.print("Arduino UNO Q");
lcd.setCursor(0, 2);
lcd.print("LCD 20x4 I2C");
lcd.setCursor(0, 3);
lcd.print("DIYables.io");
Monitor.println("LCD 20x4 Hello World done");
}
void loop() {}
Schnellschritte
- Erste Verwendung mit Arduino UNO Q? Folgen Sie der Erste Schritte mit Arduino UNO Q Anleitung, um Ihre Entwicklungsumgebung vorzubereiten, bevor Sie fortfahren.
- LCD verdrahten: Verbinden Sie VCC→5V, GND→GND, SDA→SDA, SCL→SCL.
- Verbinden: Stecken Sie den Arduino UNO Q mit einem USB-C-Kabel in Ihren Computer.
- Öffnen Sie Arduino App Lab: Starten Sie Arduino App Lab und warten Sie, bis Ihr Arduino UNO Q erkannt wird.
- Erstellen Sie eine neue App: Klicken Sie auf die Schaltfläche Neue App erstellen.
- Geben Sie der App einen Namen, zum Beispiel: DIYables_LCD_20x4
- Klicken Sie auf Erstellen, um zu bestätigen.
- Es wird ein Satz von Ordnern und Dateien in Ihrer neuen App generiert.
- Suchen Sie die Datei sketch/sketch.ino — dies ist der Ort, an dem Sie den MCU-Sketch einfügen.
Sketch einfügen: Kopieren Sie den MCU-Code oben und fügen Sie ihn in die Sketchdatei ein.
- Install the library: Click the Add sketch library button (the open book icon with a + sign) in the left sidebar.
- Search for Arduino_RouterBridge created by Arduino and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Search for DIYables LCD I2C created by DIYables.io and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Upload: Klicken Sie auf die Schaltfläche Ausführen in Arduino App Lab, um zu kompilieren und auf die STM32 hochzuladen.
Schauen Sie auf das LCD — alle vier Reihen zeigen Text an: "Hello, World!", "Arduino UNO Q", "LCD 20x4 I2C" und "DIYables.io"!
※ Notiz:
Wenn das LCD nichts anzeigt oder nur schwarze Quadrate, passen Sie das Kontrast-Potentiometer auf dem I2C-Backpack an. Weitere Hilfe finden Sie unter Fehlerbehebung LCD I2C.
Arduino UNO Q Code — Text und Zahlen auf LCD 20x4 anzeigen
Dieses Beispiel zeigt, wie Sie eine einfache Textzeichenfolge, eine Ganzzahl, eine Dezimalzahl und eine Hexadezimalzahl anzeigen — jeweils eine auf einer Reihe.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-lcd-20x4
*/
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 20, 4); // I2C address 0x27, 20 columns, 4 rows
void setup() {
Monitor.begin(9600);
lcd.init();
lcd.backlight();
// Row 0: plain text string
lcd.setCursor(0, 0);
lcd.print("Text: Arduino UNO Q");
// Row 1: integer
int count = 2025;
lcd.setCursor(0, 1);
lcd.print("Int: ");
lcd.print(count);
// Row 2: float (2 decimal places)
float voltage = 3.14;
lcd.setCursor(0, 2);
lcd.print("Float:");
lcd.print(voltage, 2);
// Row 3: hexadecimal
int value = 255;
lcd.setCursor(0, 3);
lcd.print("Hex: 0x");
lcd.print(value, HEX);
Monitor.println("LCD 20x4 text demo done");
}
void loop() {}
Schnellschritte
- Kopieren Sie den Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Klicken Sie auf die Schaltfläche Ausführen in Arduino App Lab.
Das LCD zeigt Text auf Reihe 0, eine Ganzzahl auf Reihe 1, eine Dezimalzahl auf Reihe 2 und eine Hexadezimalzahl auf Reihe 3.
Nützliche LCD-Funktionen - Referenz
Kurzreferenz für häufig verwendete DIYables_LCD_I2C Funktionen:
- lcd.init() — LCD initialisieren
- lcd.backlight() — Beleuchtung einschalten
- lcd.noBacklight() — Beleuchtung ausschalten
- lcd.setCursor(col, row) — Verschieben Sie den Cursor zu Spalte *col*, Reihe *row* (beide sind 0-basiert)
- lcd.print("text") — Drucken Sie eine Zeichenfolge an der aktuellen Cursorposition
- lcd.print(number) — Drucken Sie eine Ganzzahl
- lcd.print(number, HEX) — Drucken Sie eine Ganzzahl in Hexadezimal
- lcd.print(floatVal, decimals) — Drucken Sie einen Dezimalzahl mit der angegebenen Anzahl von Dezimalstellen
- lcd.clear() — Löschen Sie die Anzeige und verschieben Sie den Cursor zu (0, 0)
- lcd.home() — Verschieben Sie den Cursor zu (0, 0) ohne zu löschen
- lcd.createChar(id, array) — Registrieren Sie ein benutzerdefiniertes Zeichen (ID 0–7)
- lcd.write((byte)id) — Zeige ein registriertes benutzerdefiniertes Zeichen an
- lcd.scrollDisplayLeft() — Verschieben Sie alle Inhalte eine Spalte nach links
- lcd.scrollDisplayRight() — Verschieben Sie alle Inhalte eine Spalte nach rechts
- lcd.cursor() — Zeigen Sie den Unterstrich-Cursor
- lcd.noCursor() — Verstecken Sie den Cursor
- lcd.blink() — Zeigen Sie den blinkenden Block-Cursor
- lcd.noBlink() — Beenden Sie den blinkenden Block-Cursor
Arduino UNO Q Code — Benutzerdefinierte Zeichen auf LCD 20x4
Das LCD 20x4 kann bis zu 8 benutzerdefinierte Zeichen speichern (IDs 0–7). Jedes Zeichen wird als eine 8-Reihen × 5-Spalten-Bitmap definiert, die in einem Byte-Array gespeichert ist. Definieren Sie die Arrays, registrieren Sie sie mit lcd.createChar(), dann zeigen Sie sie mit lcd.write() an.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-lcd-20x4
*/
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 20, 4); // I2C address 0x27, 20 columns, 4 rows
// Custom character 0: heart
byte heart[8] = {
0b00000,
0b01010,
0b11111,
0b11111,
0b01110,
0b00100,
0b00000,
0b00000
};
// Custom character 1: smiley face
byte smiley[8] = {
0b00000,
0b01010,
0b01010,
0b00000,
0b10001,
0b01110,
0b00000,
0b00000
};
// Custom character 2: music note
byte note[8] = {
0b00100,
0b00110,
0b00101,
0b00101,
0b00100,
0b11100,
0b11100,
0b00000
};
// Custom character 3: arrow up
byte arrowUp[8] = {
0b00100,
0b01110,
0b11111,
0b00100,
0b00100,
0b00100,
0b00100,
0b00000
};
void setup() {
Monitor.begin(9600);
lcd.init();
lcd.backlight();
// Register custom characters (slots 0–3)
lcd.createChar(0, heart);
lcd.createChar(1, smiley);
lcd.createChar(2, note);
lcd.createChar(3, arrowUp);
// Row 0: label + heart
lcd.setCursor(0, 0);
lcd.print("Heart: ");
lcd.write((byte)0);
// Row 1: label + smiley
lcd.setCursor(0, 1);
lcd.print("Smiley: ");
lcd.write((byte)1);
// Row 2: label + note
lcd.setCursor(0, 2);
lcd.print("Note: ");
lcd.write((byte)2);
// Row 3: label + arrow up
lcd.setCursor(0, 3);
lcd.print("Arrow up: ");
lcd.write((byte)3);
Monitor.println("LCD 20x4 custom characters done");
}
void loop() {}
Schnellschritte
- Kopieren Sie den Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Klicken Sie auf die Schaltfläche Ausführen in Arduino App Lab.
Das LCD zeigt vier Reihen an, jeweils gekennzeichnet mit dem am Ende gezeigten benutzerdefinierten Zeichen: Herz, smiley, Musiknote und Pfeil.
※ Notiz:
Um Ihre eigenen Zeichen zu entwerfen, verwenden Sie den LCD Custom Character Generator — damit können Sie das Pixelmuster zeichnen und das Byte-Array für Ihren Code ausgeben.
Arduino UNO Q Code — Scrollen von Text auf LCD 20x4
scrollDisplayLeft() und scrollDisplayRight() verschieben den gesamten Displayinhalt um eine Spalte pro Aufruf — alle vier Reihen bewegen sich zusammen. Verwenden Sie eine Schleife mit einer kurzen Verzögerung, um einen sanften Scroll-Effekt zu erzeugen.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-lcd-20x4
*/
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 20, 4); // I2C address 0x27, 20 columns, 4 rows
void setup() {
Monitor.begin(9600);
lcd.init();
lcd.backlight();
// Write text on all 4 rows
lcd.setCursor(0, 0);
lcd.print("Scroll Left >>>>>");
lcd.setCursor(0, 1);
lcd.print("Row 1 scrolling...");
lcd.setCursor(0, 2);
lcd.print("Row 2 scrolling...");
lcd.setCursor(0, 3);
lcd.print("<<< Scroll Right");
delay(1000);
// Scroll entire display left 20 steps
Monitor.println("Scrolling left...");
for (int i = 0; i < 20; i++) {
lcd.scrollDisplayLeft();
delay(300);
}
delay(500);
// Scroll entire display right 20 steps (back to original)
Monitor.println("Scrolling right...");
for (int i = 0; i < 20; i++) {
lcd.scrollDisplayRight();
delay(300);
}
Monitor.println("LCD 20x4 scroll demo done");
}
void loop() {}
Schnellschritte
- Kopieren Sie den Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Klicken Sie auf die Schaltfläche Ausführen in Arduino App Lab.
Der LCD-Inhalt verschiebt sich 20 Schritte nach links, pausiert, dann verschiebt sich 20 Schritte nach rechts zurück zur ursprünglichen Position.
Arduino UNO Q Code — Beleuchtungskontrolle auf LCD 20x4
Verwenden Sie lcd.backlight(), um die Beleuchtungs-LED des I2C-Backpacks einzuschalten, und lcd.noBacklight(), um sie auszuschalten. Diese Demo durchläuft das Muster ein → aus → ein → Blinken.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-lcd-20x4
*/
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 20, 4); // I2C address 0x27, 20 columns, 4 rows
void setup() {
Monitor.begin(9600);
lcd.init();
lcd.backlight();
lcd.setCursor(0, 0);
lcd.print("Backlight ON");
lcd.setCursor(0, 1);
lcd.print("Arduino UNO Q");
lcd.setCursor(0, 2);
lcd.print("LCD 20x4 I2C");
lcd.setCursor(0, 3);
lcd.print("DIYables.io");
Monitor.println("Backlight ON");
delay(2000);
// Turn off backlight
lcd.noBacklight();
Monitor.println("Backlight OFF");
delay(2000);
// Turn backlight back on
lcd.backlight();
Monitor.println("Backlight ON again");
delay(2000);
// Blink the backlight 5 times
Monitor.println("Blinking backlight...");
for (int i = 0; i < 5; i++) {
lcd.noBacklight();
delay(500);
lcd.backlight();
delay(500);
}
Monitor.println("LCD 20x4 backlight demo done");
}
void loop() {}
Schnellschritte
- Kopieren Sie den Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Klicken Sie auf die Schaltfläche Ausführen in Arduino App Lab.
Beobachten Sie, wie die LCD-Beleuchtung eingeschaltet wird, dann ausgeschaltet wird, dann wieder eingeschaltet wird und schließlich fünfmal blinkt.
Arduino UNO Q Code — Cursor und Blinken auf LCD 20x4
Das LCD unterstützt zwei Cursor-Stile: einen Unterstrich-Cursor (lcd.cursor()) und einen blinkenden Block-Cursor (lcd.blink()). Sie können einzeln oder zusammen angezeigt werden.
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-lcd-20x4
*/
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 20, 4); // I2C address 0x27, 20 columns, 4 rows
void setup() {
Monitor.begin(9600);
lcd.init();
lcd.backlight();
// Show underscore cursor
lcd.setCursor(0, 0);
lcd.print("Cursor visible:");
lcd.setCursor(0, 1);
lcd.print("Pos (0,1) > ");
lcd.cursor(); // Show underscore cursor
Monitor.println("cursor() — underscore cursor ON");
delay(3000);
// Hide cursor
lcd.noCursor();
Monitor.println("noCursor() — cursor hidden");
delay(2000);
// Show blinking block cursor
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Blink cursor:");
lcd.setCursor(0, 1);
lcd.print("Pos (0,1) > ");
lcd.blink(); // Show blinking block cursor
Monitor.println("blink() — blinking cursor ON");
delay(3000);
// Stop blinking
lcd.noBlink();
Monitor.println("noBlink() — blinking cursor OFF");
delay(2000);
// Show both cursor and blink together
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Cursor + Blink:");
lcd.setCursor(0, 1);
lcd.print("Pos (0,1) > ");
lcd.cursor();
lcd.blink();
Monitor.println("cursor() + blink() — both ON");
delay(3000);
// Turn off both
lcd.noCursor();
lcd.noBlink();
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Cursor demo done");
Monitor.println("LCD 20x4 cursor demo done");
}
void loop() {}
Schnellschritte
- Kopieren Sie den Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Klicken Sie auf die Schaltfläche Ausführen in Arduino App Lab.
Das LCD durchläuft: Unterstrich-Cursor sichtbar → versteckt → blinkender Block-Cursor → gestoppt → Cursor und Blinken zusammen → beide aus.
Linux + MCU Bridge-Programmierung
Der Arduino UNO Q hat zwei Prozessoren, die zusammenarbeiten: die MPU (Qualcomm, läuft Debian Linux) und die MCU (STM32, läuft Zephyr OS mit Ihrem Arduino Sketch). Sie kommunizieren über RPC über die Arduino_RouterBridge Bibliothek — niemals über raw serielle Ports.
- Das LCD ist mit der MCU (STM32) verbunden — über I2C (SDA/SCL). Nur die MCU kann direkt darin schreiben.
- Die MPU kann das LCD nicht direkt steuern — sie ruft MCU-Funktionen wie Bridge.call("set_line1", "text") auf, um jede Reihe zu aktualisieren.
- Die MPU hat Wi-Fi — weil die MPU vollständiges Debian Linux mit Wi-Fi läuft, kann sie Telegram-Befehle empfangen und jede Nachricht auf dem LCD anzeigen.
- Kommunikation: Bridge.call() auf der Linux-Seite ruft Bridge.provide_safe() Funktionen auf der MCU-Seite auf (da LCD-Schreibvorgänge Hardware-API-Aufrufe sind).
- ⚠️ Reserviert: /dev/ttyHS1 (Linux) und Serial1 (MCU) werden vom Arduino Router verwendet — öffnen Sie sie niemals direkt.
Kurz gesagt: MPU sendet Text über Bridge → MCU schreibt zu LCD-Reihe → MCU druckt Ergebnis zu Monitor.
MCU Sketch — LCD 20x4 mit Bridge und Monitor-Ausgabe:
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-lcd-20x4
*/
#include "Arduino_RouterBridge.h"
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 20, 4); // I2C address 0x27, 20 columns, 4 rows
String lines[4] = {"", "", "", ""};
void set_line1(String text) {
lines[0] = text.substring(0, 20);
lcd.setCursor(0, 0);
lcd.print(" "); // Clear row 0
lcd.setCursor(0, 0);
lcd.print(lines[0]);
Monitor.println("Row0: " + lines[0]);
}
void set_line2(String text) {
lines[1] = text.substring(0, 20);
lcd.setCursor(0, 1);
lcd.print(" "); // Clear row 1
lcd.setCursor(0, 1);
lcd.print(lines[1]);
Monitor.println("Row1: " + lines[1]);
}
void set_line3(String text) {
lines[2] = text.substring(0, 20);
lcd.setCursor(0, 2);
lcd.print(" "); // Clear row 2
lcd.setCursor(0, 2);
lcd.print(lines[2]);
Monitor.println("Row2: " + lines[2]);
}
void set_line4(String text) {
lines[3] = text.substring(0, 20);
lcd.setCursor(0, 3);
lcd.print(" "); // Clear row 3
lcd.setCursor(0, 3);
lcd.print(lines[3]);
Monitor.println("Row3: " + lines[3]);
}
void clear_lcd() {
for (int i = 0; i < 4; i++) lines[i] = "";
lcd.clear();
Monitor.println("LCD cleared");
}
void get_status() {
Monitor.println("R0: " + lines[0]);
Monitor.println("R1: " + lines[1]);
Monitor.println("R2: " + lines[2]);
Monitor.println("R3: " + lines[3]);
}
void setup() {
Bridge.begin();
Monitor.begin();
lcd.init();
lcd.backlight();
lcd.setCursor(0, 0);
lcd.print("Bridge Ready");
lcd.setCursor(0, 1);
lcd.print("Waiting...");
Bridge.provide_safe("set_line1", set_line1);
Bridge.provide_safe("set_line2", set_line2);
Bridge.provide_safe("set_line3", set_line3);
Bridge.provide_safe("set_line4", set_line4);
Bridge.provide_safe("clear_lcd", clear_lcd);
Bridge.provide("get_status", get_status);
Monitor.println("LCD 20x4 Bridge ready");
}
void loop() {}
Python-Skript (Arduino App Lab) — Text auf LCD 20x4 von Linux anzeigen:
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-lcd-20x4
*/
from arduino.app_utils import *
import time
def loop():
Bridge.call("set_line1", "Arduino UNO Q")
Bridge.call("set_line2", "LCD 20x4 Bridge")
Bridge.call("set_line3", "DIYables.io")
Bridge.call("set_line4", "Python running...")
time.sleep(3)
Bridge.call("clear_lcd")
time.sleep(1)
Bridge.call("set_line1", "Line 1 update")
Bridge.call("set_line2", "Line 2 update")
result = Bridge.call("get_status")
print(result)
time.sleep(3)
App.run(user_loop=loop)
Schnellschritte
- Erstellen Sie eine neue App: Öffnen Sie Arduino App Lab, klicken Sie auf Neue App erstellen, nennen Sie sie DIYables_LCD_20x4_Bridge, und klicken Sie auf Erstellen.
- Einfügen des MCU Sketch: Kopieren Sie den Bridge MCU Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Einfügen des Python-Skripts: Kopieren Sie den Python Code oben und fügen Sie ihn in die Python-Datei in der App ein.
- Ausführen der App: Klicken Sie auf die Schaltfläche Ausführen — die Python-Seite aktualisiert alle vier LCD-Reihen, dann löscht und aktualisiert sie erneut.
App Lab Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
LCD 20x4 Bridge ready
Row0: Arduino UNO Q
Row1: LCD 20x4 Bridge
Row2: DIYables.io
Row3: Python running...
LCD cleared
Row0: Line 1 update
Row1: Line 2 update
R0: Line 1 update
R1: Line 2 update
R2:
R3:
Telegram-Integration
Steuern Sie Ihr LCD 20x4 remote — senden Sie Text auf eine beliebige Reihe von überall aus über Telegram.
Wenn Sie noch keinen Telegram-Bot haben, siehe How to Create a Telegram Bot um Ihr Bot-Token zu erhalten, bevor Sie fortfahren.
MCU Sketch: Behalten Sie den selben MCU Sketch aus dem vorherigen Bridge-Abschnitt — keine Änderungen erforderlich. Stellen Sie sicher, dass er bereits auf die STM32 hochgeladen und ausgeführt wird, bevor Sie fortfahren.
Python-Skript (Arduino App Lab) — Telegram-Bot für LCD 20x4:
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/arduino-uno-q/arduino-uno-q-lcd-20x4
*/
from arduino.app_utils import *
import requests
import time
BOT_TOKEN = "YOUR_BOT_TOKEN"
API_URL = f"https://api.telegram.org/bot{BOT_TOKEN}"
last_update_id = 0
def send_message(chat_id, text):
requests.post(f"{API_URL}/sendMessage", json={"chat_id": chat_id, "text": text})
def get_updates():
global last_update_id
resp = requests.get(f"{API_URL}/getUpdates", params={"offset": last_update_id + 1, "timeout": 5})
return resp.json().get("result", [])
def loop():
global last_update_id
updates = get_updates()
for update in updates:
last_update_id = update["update_id"]
msg = update.get("message", {})
chat_id = msg.get("chat", {}).get("id")
text = msg.get("text", "").strip()
if text.startswith("/row1 "):
result = Bridge.call("set_line1", text[6:])
send_message(chat_id, result)
elif text.startswith("/row2 "):
result = Bridge.call("set_line2", text[6:])
send_message(chat_id, result)
elif text.startswith("/row3 "):
result = Bridge.call("set_line3", text[6:])
send_message(chat_id, result)
elif text.startswith("/row4 "):
result = Bridge.call("set_line4", text[6:])
send_message(chat_id, result)
elif text == "/clear":
result = Bridge.call("clear_lcd")
send_message(chat_id, result)
elif text == "/status":
result = Bridge.call("get_status")
send_message(chat_id, result)
else:
send_message(chat_id, "Commands:\n/row1 <text>\n/row2 <text>\n/row3 <text>\n/row4 <text>\n/clear\n/status")
App.run(user_loop=loop)
- Hinweis: Ersetzen Sie YOUR_BOT_TOKEN durch das Token, das Sie von @BotFather auf Telegram erhalten haben.
- Senden Sie /row1 Hello — zeigt "Hello" auf Reihe 1 an.
- Senden Sie /row2 World — zeigt "World" auf Reihe 2 an.
- Senden Sie /clear — löscht das gesamte LCD.
- Senden Sie /status — gibt den aktuellen Inhalt aller 4 Reihen zurück.
Schnellschritte
- MCU Sketch hochladen: Verwenden Sie den Bridge MCU Sketch aus dem vorherigen Abschnitt.
- Einfügen des Telegram-Skripts: Kopieren Sie den Python Code oben in die Python-Registerkarte.
- Legen Sie Ihr Token fest: Ersetzen Sie YOUR_BOT_TOKEN durch Ihr tatsächliches Bot-Token.
- Ausführen der App: Klicken Sie auf Ausführen — der Bot wartet auf Telegram-Befehle.
- Testen Sie es: Senden Sie /row1 Arduino UNO Q — dieser Text sollte auf der ersten Reihe des LCD angezeigt werden.
App Lab Python-Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 12:00:01] Telegram: /row1 Arduino UNO Q
[2026-04-29 12:00:01] Row0: Arduino UNO Q
[2026-04-29 12:01:10] Telegram: /row3 DIYables.io
[2026-04-29 12:01:10] Row2: DIYables.io
[2026-04-29 12:02:00] Telegram: /status
[2026-04-29 12:02:00] R0: Arduino UNO Q | R1: | R2: DIYables.io | R3:
[2026-04-29 12:03:15] Telegram: /clear
[2026-04-29 12:03:15] LCD cleared
Telegram
12:45
Welcome to Telegram!
ArduinoBot
10:19
Chatting with Arduino...
BotFather
Yesterday
Your bot has been created.
ArduinoBot
bot
OpenClaw-Integration
Sie können die OpenClaw-Integration auf diese Anleitung anwenden, indem Sie der Anweisung auf Arduino Uno Q - OpenClaw Anleitung folgen
Anwendungs-/Projektideen
- 4-Reihen-Sensor-Dashboard: Zeigen Sie gleichzeitig Temperatur, Luftfeuchtigkeit, Druck und Akkuladung auf allen vier Reihen an
- Netzwerk-Statusfeld: Zeigen Sie IP-Adresse, verbundene Geräte, Betriebszeit und letztes Ereignis auf dedizierten Reihen
- Lab-Ausrüstungsanzeige: Verwenden Sie die 20x4, um Mehrkanal-Sensormessungen in einem kompakten Format anzuzeigen
- Countdown-Timer-Tafel: Zeigen Sie einen großformatige Timer auf allen 4 Reihen für einfaches Lesen auf der anderen Seite des Raumes
- Remote-Nachrichtentafel: Verwenden Sie Telegram, um 4-zeilige Ankündigungen auf ein LCD an einer Wand oder einem Schreibtisch zu drücken
Sich selbst herausfordern
- Einfach: Ändern Sie die /status Antwort so, dass die 4 Reihen als Row 1: text | Row 2: text | Row 3: text | Row 4: text in einer einzelnen Nachricht formatiert sind
- Mittel: Fügen Sie einen /display <text> Befehl hinzu, der langen Text automatisch auf bis zu 4 Reihen mit je 20 Zeichen umbreitet
- Fortgeschrittene: Implementieren Sie einen scrolling Ticker unter Verwendung von lcd.scrollDisplayLeft(), der eine lange Nachricht von Telegram über alle 4 Reihen anzeigt