Arduino UNO Q - LCD I2C
In diesem Tutorial erfahren Sie, wie Sie ein LCD I2C 16x2 Display mit Arduino UNO Q verwenden — vom einfachen Text bis zu benutzerdefinierten Zeichen, Scrollen und Telegram-Fernsteuerung.
- So verbinden Sie ein LCD I2C mit Arduino UNO Q
- So zeigen Sie "Hello World" Text auf beiden Reihen an
- So zeigen Sie Text, Ganzzahlen, Dezimalzahlen und Hexadezimalzahlen auf dem LCD an
- So erstellen und zeigen Sie benutzerdefinierte Zeichen auf dem LCD an
- So scrollen Sie Text auf dem LCD-Display
- So steuern Sie die LCD-Hintergrundbeleuchtung
- So verwenden Sie Cursor- und Blinkmodis
- So steuern Sie das LCD remote aus Linux via Bridge-Programmierung
- So steuern Sie das LCD remote aus Telegram via 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 16x2
Das LCD I2C kombiniert ein Standard 16x2 LCD-Panel mit einem I2C-Backpack-Modul. Die Verwendung der I2C-Schnittstelle reduziert die Verdrahtung auf nur 4 Drähte — viel einfacher als ein paralleles LCD-Anschluss.
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 16x2 hat 16 Spalten und 2 Reihen, wobei Spalten und Reihen ab 0 nummeriert sind.
Schaltplan
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 des LCD kann je nach Hersteller unterschiedlich sein. In diesem Tutorial verwenden wir 0x27, die Standardadresse für DIYables Module.
Wie man das LCD I2C programmiert
Die Bibliothek DIYables_LCD_I2C macht die Steuerung des LCD einfach.
- Bibliothek einbinden:
#include <DIYables_LCD_I2C.h>
- Erstellen Sie ein LCD-Objekt mit I2C-Adresse, Anzahl der Spalten und Anzahl der Reihen:
DIYables_LCD_I2C lcd(0x27, 16, 2); // I2C-Adresse 0x27, 16 Spalten, 2 Reihen
- Initialisieren Sie das LCD in setup():
lcd.init(); // Initialisieren Sie das LCD
lcd.backlight(); // Schalten Sie die Hintergrundbeleuchtung ein
- Verschieben Sie den Cursor auf eine Position (Spalte, Reihe):
lcd.setCursor(column_index, row_index);
- Drucken Sie Text auf der aktuellen Cursor-Position:
lcd.print("Hello World!");
Siehe den Abschnitt "Mehr mit LCD" für Scrollen, benutzerdefinierte Zeichen und mehr.
※ Notiz:
Die I2C-Adresse kann je nach Hersteller unterschiedlich sein. Wir verwenden 0x27 wie von DIYables angegeben.
Arduino UNO Q Code — Hello World auf LCD I2C
Arduino UNO Q hat zwei Prozessoren: den STM32 MCU (handhabt die Hardware-Echtzeitsteuerung) und den Qualcomm MPU (läuft Debian Linux). In diesem Abschnitt wird nur der STM32 MCU programmiert — die Linux-Seite bleibt inaktiv. Ein späterer Abschnitt zeigt, wie beide Prozessoren zusammenarbeiten.
Die folgende Skizze zeigt Text auf beiden 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-i2c
*/
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 16, 2); // I2C address 0x27, 16 columns, 2 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");
Monitor.println("LCD I2C Hello World done");
}
void loop() {}
Schnelle Schritte
- Zum ersten Mal mit Arduino UNO Q? Folgen Sie dem Getting Started with Arduino UNO Q Tutorial, um Ihre Entwicklungsumgebung vorzubereiten, bevor Sie fortfahren.
- Verdrahten Sie das LCD: Verbinden Sie VCC→5V, GND→GND, SDA→SDA, SCL→SCL.
- Verbinden: Schließen Sie Arduino UNO Q mit einem USB-C-Kabel an Ihren Computer an.
- Öffnen Sie Arduino App Lab: Starten Sie Arduino App Lab und warten Sie, bis es Ihr Arduino UNO Q erkennt.
- Erstellen Sie eine neue App: Klicken Sie auf die Schaltfläche Neue App erstellen.
- Geben Sie der App einen Namen, zum Beispiel: DIYables_LCD_I2C
- Klicken Sie auf Erstellen, um zu bestätigen.
- Sie werden einen Satz von Ordnern und Dateien sehen, die in Ihrer neuen App generiert werden.
- Finden Sie die Datei sketch/sketch.ino — hier fügen Sie die MCU-Skizze ein.
Fügen Sie die Skizze ein: Kopieren Sie den MCU-Code oben und fügen Sie ihn in die Sketch-Datei 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
- Hochladen: Klicken Sie auf die Schaltfläche Ausführen in Arduino App Lab, um zu kompilieren und in den STM32 hochzuladen.
Schauen Sie sich das LCD an — Reihe 0 zeigt "Hello, World!" und Reihe 1 zeigt "Arduino UNO Q"!
※ Notiz:
Wenn das LCD nichts anzeigt oder nur schwarze Quadrate, passen Sie den Kontrastpotentiometer auf der Rückseite des I2C-Moduls mit einem kleinen Schraubenzieher an. Siehe Fehlerbehebung bei LCD I2C für weitere Hilfe.
Arduino UNO Q Code — Text und Zahlen auf LCD I2C anzeigen
Dieses Beispiel zeigt, wie man Text, eine Ganzzahl, eine Dezimalzahl und eine Hexadezimalzahl auf dem LCD anzeigt.
/*
* 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-i2c
*/
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 16, 2); // I2C address 0x27, 16 columns, 2 rows
void setup() {
Monitor.begin(9600);
lcd.init();
lcd.backlight();
// Row 0: plain text string
lcd.setCursor(0, 0);
lcd.print("Text: UNO Q");
// Row 1: integer
int count = 2025;
lcd.setCursor(0, 1);
lcd.print("Int: ");
lcd.print(count);
delay(3000);
// Row 0: float (2 decimal places)
float voltage = 3.14;
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Float: ");
lcd.print(voltage, 2);
// Row 1: hexadecimal
int value = 255;
lcd.setCursor(0, 1);
lcd.print("Hex: 0x");
lcd.print(value, HEX);
Monitor.println("LCD I2C text demo done");
}
void loop() {}
Schnelle Schritte
- Kopieren Sie den obigen Code 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 zuerst Text und eine Ganzzahl an, dann nach 3 Sekunden löscht und zeigt eine Dezimalzahl und eine Hexadezimalzahl.
Nützliche LCD-Funktionen Referenz
Schnelle Referenz für häufig verwendete DIYables_LCD_I2C Funktionen:
- lcd.init() — LCD initialisieren
- lcd.backlight() — Hintergrundbeleuchtung einschalten
- lcd.noBacklight() — Hintergrundbeleuchtung ausschalten
- lcd.setCursor(col, row) — Cursor zu Spalte *col*, Reihe *row* verschieben (beide 0-basiert)
- lcd.print("text") — String auf der aktuellen Cursor-Position drucken
- lcd.print(number) — Ganzzahl drucken
- lcd.print(number, HEX) — Ganzzahl in Hexadezimal drucken
- lcd.print(floatVal, decimals) — Dezimalzahl mit angegebener Dezimalstellenanzahl drucken
- lcd.clear() — Display löschen und Cursor zu (0, 0) verschieben
- lcd.home() — Cursor zu (0, 0) verschieben ohne zu löschen
- lcd.createChar(id, array) — Benutzerdefiniertes Zeichen registrieren (ID 0–7)
- lcd.write((byte)id) — Registriertes benutzerdefiniertes Zeichen anzeigen
- lcd.scrollDisplayLeft() — Alle Inhalte eine Spalte nach links verschieben
- lcd.scrollDisplayRight() — Alle Inhalte eine Spalte nach rechts verschieben
- lcd.cursor() — Unterstrich-Cursor anzeigen
- lcd.noCursor() — Cursor ausblenden
- lcd.blink() — Blinkenden Block-Cursor anzeigen
- lcd.noBlink() — Blinkenden Block-Cursor stoppen
Arduino UNO Q Code — Benutzerdefinierte Zeichen auf LCD I2C
lcd.print() funktioniert nur mit ASCII-Zeichen. Um ein spezielles Symbol anzuzeigen (z.B. Herz, Pfeil), definieren Sie ein benutzerdefiniertes Zeichen mit 8 Bytes Pixeldaten. Eine LCD 16x2 Zeichenzelle ist 8 Reihen × 5 Spalten Pixel — Sie können bis zu 8 benutzerdefinierte Zeichen speichern (IDs 0–7).
Verwenden Sie den Zeichengenerator unten, um Ihr Zeichen zu entwerfen und den Binärcode zu erhalten:
Klicken Sie auf jeden Pixel, um auszuwählen/abzuwählen
Kopieren Sie den unten stehenden Code für benutzerdefinierte Zeichen
Ersetzen Sie die customChar[8] im unten stehenden Code
/*
* 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-i2c
*/
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 16, 2); // I2C address 0x27, 16 columns, 2 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: heart + smiley
lcd.setCursor(0, 0);
lcd.print("Heart:");
lcd.write((byte)0);
lcd.print(" Smile:");
lcd.write((byte)1);
// Row 1: note + arrow
lcd.setCursor(0, 1);
lcd.print("Note:");
lcd.write((byte)2);
lcd.print(" Up:");
lcd.write((byte)3);
Monitor.println("LCD I2C custom characters done");
}
void loop() {}
Schnelle Schritte
- Kopieren Sie den obigen Code 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 benutzerdefinierte Symbole an: Herz, Smiley, Musiknote und Pfeil — zwei pro Reihe.
※ Notiz:
Um Ihre eigenen Zeichen zu entwerfen, verwenden Sie den LCD Custom Character Generator — er ermöglicht es Ihnen, das Pixelmuster zu zeichnen und gibt das Byte-Array aus, das für Ihren Code bereit ist. Sie können auch den interaktiven Generator oben verwenden.
Arduino UNO Q Code — Scrollen von Text auf LCD I2C
scrollDisplayLeft() und scrollDisplayRight() verschieben den gesamten Displayinhalt um eine Spalte pro Aufruf — beide Reihen bewegen sich zusammen. Verwenden Sie eine Schleife mit einer kurzen Verzögerung, um einen sanften Scroll-Effekt zu erstellen.
/*
* 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-i2c
*/
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 16, 2); // I2C address 0x27, 16 columns, 2 rows
void setup() {
Monitor.begin(9600);
lcd.init();
lcd.backlight();
// Write text on both rows
lcd.setCursor(0, 0);
lcd.print("Scroll Left >>>>");
lcd.setCursor(0, 1);
lcd.print("<<< Scroll Right");
delay(1000);
// Scroll entire display left 16 steps
Monitor.println("Scrolling left...");
for (int i = 0; i < 16; i++) {
lcd.scrollDisplayLeft();
delay(300);
}
delay(500);
// Scroll entire display right 16 steps (back to original)
Monitor.println("Scrolling right...");
for (int i = 0; i < 16; i++) {
lcd.scrollDisplayRight();
delay(300);
}
Monitor.println("LCD I2C scroll demo done");
}
void loop() {}
Schnelle Schritte
- Kopieren Sie den obigen Code 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 rutscht 16 Schritte nach links, macht Pause und rutscht dann 16 Schritte zurück nach rechts.
Arduino UNO Q Code — Hintergrundbeleuchtungssteuerung auf LCD I2C
Verwenden Sie lcd.backlight(), um die Hintergrundbeleuchtungs-LED des I2C-Backpack einzuschalten, und lcd.noBacklight(), um sie auszuschalten. Diese Demo durchläuft ein Muster: an → aus → an → 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-i2c
*/
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 16, 2); // I2C address 0x27, 16 columns, 2 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");
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 I2C backlight demo done");
}
void loop() {}
Schnelle Schritte
- Kopieren Sie den obigen Code 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-Hintergrundbeleuchtung eingeschaltet, dann ausgeschaltet, dann wieder eingeschaltet wird und schließlich fünfmal blinkt.
Arduino UNO Q Code — Cursor und Blinken auf LCD I2C
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-i2c
*/
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 16, 2); // I2C address 0x27, 16 columns, 2 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 ON");
delay(3000);
// Hide cursor
lcd.noCursor();
Monitor.println("noCursor() — 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 ON");
delay(3000);
// Stop blinking
lcd.noBlink();
Monitor.println("noBlink() — blinking 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 I2C cursor demo done");
}
void loop() {}
Schnelle Schritte
- Kopieren Sie den obigen Code 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 → beide Cursor und Blinken → beide aus.
Fehlerbehebung bei LCD I2C
- LCD zeigt nichts / Hintergrundbeleuchtung aus — Überprüfen Sie VCC→5V und GND. Stellen Sie sicher, dass der lcd.backlight() Aufruf in setup() ist.
- LCD zeigt schwarze Quadrate auf beiden Reihen — Der Kontrast ist zu hoch eingestellt. Drehen Sie den Potentiometer am I2C-Backpack, um den Kontrast zu reduzieren.
- LCD zeigt schwache/unsichtbare Text — Der Kontrast ist zu niedrig eingestellt. Erhöhen Sie ihn über den Potentiometer.
- Falsche Zeichen angezeigt — Die I2C-Adresse kann falsch sein. Versuchen Sie 0x3F, wenn 0x27 nicht funktioniert, oder führen Sie eine I2C-Scanner-Skizze aus, um die Adresse zu finden.
- Skizze wird hochgeladen, aber LCD bleibt leer — Überprüfen Sie doppelt, dass SDA und SCL Verbindungen nicht vertauscht sind.
Linux + MCU Bridge-Programmierung
Arduino UNO Q hat zwei Prozessoren, die zusammenarbeiten: den MPU (Qualcomm, läuft Debian Linux) und den MCU (STM32, läuft Zephyr OS mit Ihrer Arduino-Skizze). Sie kommunizieren über RPC über die Bibliothek Arduino_RouterBridge — niemals über Raw Serial Ports.
- Das LCD ist mit dem MCU (STM32) verbunden — über den I2C-Bus (SDA/SCL). Nur der MCU kann das LCD direkt steuern.
- Der MPU kann das LCD nicht direkt steuern — Er ruft MCU-Funktionen über Bridge.call("set_line1", "text") auf, die das LCD aktualisieren und das Ergebnis zurückgeben.
- Der MPU hat Wi-Fi — weil der MPU vollständiges Debian Linux mit Wi-Fi ausführt, kann er Telegram-Befehle empfangen und jede Nachricht remote 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 nie direkt.
Kurz gesagt: MPU sendet Text via Telegram → MPU ruft Bridge auf → MCU aktualisiert LCD → MCU meldet Ergebnis zurück an MPU.
MCU-Skizze — LCD I2C 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-i2c
*/
#include "Arduino_RouterBridge.h"
#include <DIYables_LCD_I2C.h>
DIYables_LCD_I2C lcd(0x27, 16, 2); // I2C address 0x27, 16 columns, 2 rows
String current_line1 = "";
String current_line2 = "";
void set_line1(String text) {
current_line1 = text.substring(0, 16);
lcd.setCursor(0, 0);
lcd.print(" "); // Clear line 1
lcd.setCursor(0, 0);
lcd.print(current_line1);
Monitor.println("Line1: " + current_line1);
}
void set_line2(String text) {
current_line2 = text.substring(0, 16);
lcd.setCursor(0, 1);
lcd.print(" "); // Clear line 2
lcd.setCursor(0, 1);
lcd.print(current_line2);
Monitor.println("Line2: " + current_line2);
}
void clear_lcd() {
current_line1 = "";
current_line2 = "";
lcd.clear();
Monitor.println("LCD cleared");
}
void get_status() {
Monitor.println("Line1: " + current_line1 + " | Line2: " + current_line2);
}
void setup() {
Bridge.begin();
Monitor.begin();
lcd.init(); // Initialize the LCD I2C display
lcd.backlight(); // Turn on the 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("clear_lcd", clear_lcd);
Bridge.provide("get_status", get_status);
Monitor.println("LCD I2C Bridge ready");
}
void loop() {}
Python-Skript (Arduino App Lab) — Text auf LCD 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-i2c
*/
from arduino.app_utils import *
import time
def loop():
result = Bridge.call("set_line1", "Hello UNO Q")
print(result)
result = Bridge.call("set_line2", "Python Bridge")
print(result)
time.sleep(3)
result = Bridge.call("clear_lcd")
print(result)
time.sleep(2)
result = Bridge.call("set_line1", "Counting: 1")
print(result)
result = Bridge.call("set_line2", "Loop running")
print(result)
time.sleep(3)
App.run(user_loop=loop)
- Hinweis: Stellen Sie sicher, dass Bridge.begin() in der MCU-Skizze aufgerufen wird und die Skizze hochgeladen ist, bevor Sie das Python-Skript ausführen.
- ⚠️ Warnung: Öffnen Sie nie direkt /dev/ttyHS1 (unter Linux) oder verwenden Sie Serial1 (auf MCU) — diese sind vom Arduino Router reserviert.
Schnelle Schritte
- Erstellen Sie eine neue App: Öffnen Sie Arduino App Lab, klicken Sie auf Neue App erstellen, benennen Sie sie DIYables_LCD_I2C_Bridge und klicken Sie auf Erstellen.
- Fügen Sie die MCU-Skizze ein: Kopieren Sie den Bridge MCU-Code oben und fügen Sie ihn in sketch/sketch.ino ein.
- Fügen Sie das Python-Skript ein: Kopieren Sie den Python-Code oben und fügen Sie ihn in die Python-Datei in der App ein.
- Führen Sie die App aus: Klicken Sie auf die Schaltfläche Ausführen — die Python-Seite aktualisiert das LCD alle paar Sekunden.
App Lab Konsolen-Ausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
LCD I2C Bridge ready
Line1: Hello UNO Q
Line2: Python Bridge
LCD cleared
Line1: Counting: 1
Line2: Loop running
Telegram-Integration
Senden Sie jede Nachricht zu Ihrem LCD von überall auf der Welt über Telegram.
Wenn Sie noch keinen Telegram-Bot haben, sehen Sie sich How to Create a Telegram Bot an, um Ihr Bot-Token vor dem Fortfahren zu erhalten.
MCU-Skizze: Behalten Sie die gleiche MCU-Skizze aus dem vorherigen Bridge-Abschnitt — keine Änderungen erforderlich. Stellen Sie sicher, dass sie bereits auf dem STM32 hochgeladen und ausgeführt wird, bevor Sie fortfahren.
Python-Skript (Arduino App Lab) — Telegram-Bot zur LCD-Steuerung:
/*
* 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-i2c
*/
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("/display "):
content = text[9:]
line1 = content[:16]
line2 = content[16:32] if len(content) > 16 else ""
result1 = Bridge.call("set_line1", line1)
print(f"[Telegram] /display: {line1}")
if line2:
result2 = Bridge.call("set_line2", line2)
print(result2)
send_message(chat_id, result1)
elif text == "/clear":
result = Bridge.call("clear_lcd")
print(f"[Telegram] /clear")
send_message(chat_id, result)
elif text == "/status":
result = Bridge.call("get_status")
print(f"[Telegram] /status: {result}")
send_message(chat_id, result)
else:
send_message(chat_id, "Commands:\n/display <text> — display text on LCD\n/clear — clear the LCD\n/status — show current LCD content")
App.run(user_loop=loop)
- Hinweis: Ersetzen Sie YOUR_BOT_TOKEN durch das Token, das Sie von @BotFather auf Telegram erhalten haben.
- Senden Sie /display Hello World — der Text erscheint auf dem LCD.
- Senden Sie /clear — der LCD-Bildschirm wird gelöscht.
- Senden Sie /status — der Bot antwortet mit dem aktuellen LCD-Inhalt.
Schnelle Schritte
- Laden Sie die MCU-Skizze hoch: Verwenden Sie die Bridge MCU-Skizze aus dem vorherigen Abschnitt (laden Sie sie zuerst hoch, falls noch nicht geschehen).
- Fügen Sie das Telegram-Skript ein: Kopieren Sie den Python-Code oben in die Python-Registerkarte Ihrer App in Arduino App Lab.
- Legen Sie Ihr Token fest: Ersetzen Sie YOUR_BOT_TOKEN im Skript durch Ihr aktuelles Bot-Token.
- Führen Sie die App aus: Klicken Sie auf Ausführen — der Bot beginnt, auf Telegram-Befehle zu lauschen.
- Testen Sie es: Senden Sie /display Arduino UNO Q — das LCD sollte den Text anzeigen. Senden Sie /clear, um ihn zu löschen.
App Lab Konsolen-Ausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 12:00:01] Telegram: /display Hello UNO Q
[2026-04-29 12:00:01] Line1: Hello UNO Q
[2026-04-29 12:05:10] Telegram: /status
[2026-04-29 12:05:10] Line1: Hello UNO Q | Line2:
[2026-04-29 12:10:20] Telegram: /clear
[2026-04-29 12:10:20] 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 OpenClaw an dieses Tutorial anpassen, indem Sie sich auf die Anleitung im Arduino Uno Q - OpenClaw Tutorial beziehen.
Anwendungs-/Projektideen
- IoT-Benachrichtigungstafel: Verwenden Sie Telegram, um Ankündigungen an ein LCD an einer Wand zu senden — kein Computer in der Nähe erforderlich
- Sensor-Dashboard: Zeigen Sie in Echtzeit Temperatur-, Feuchtigkeits- oder andere Sensorwerte von der MPU-Seite an
- Türalarmanzeige: Wenn ein Bewegungssensor auslöst, zeigen Sie "MOTION DETECTED" auf dem LCD an und senden Sie einen Telegram-Alert
- Wi-Fi-Wetterstation: Abrufen von Wetterdaten von einer API auf der MPU und Scrollen der Vorhersage auf dem LCD
- Countdown-Timer: Senden Sie /timer 60 via Telegram und das LCD zählt die Sekunden mit der MCU-Schleife herunter
Stellen Sie sich selbst eine Herausforderung
- Einfach: Ändern Sie den Telegram-Bot, um die Befehle /line1 <text> und /line2 <text> zu unterstützen, um jede LCD-Reihe unabhängig zu setzen
- Mittel: Fügen Sie einen /scroll <text> Befehl hinzu, der langen Text über das LCD scrollt (verwenden Sie lcd.scrollDisplayLeft() in einer Schleife)
- Fortgeschritten: Zeigen Sie Live-Sensordaten (Temperatur von einem DHT22) auf dem LCD an und halten Sie gleichzeitig Telegram-Befehle mit einem nicht-blockierenden Update-Timer responsiv