Arduino UNO Q - LCD 20x4
Ce tutoriel vous montre comment utiliser un écran LCD 20x4 I2C avec Arduino UNO Q — du texte de base aux caractères personnalisés, au défilement et au contrôle à distance via Telegram.
- Comment connecter un écran LCD 20x4 I2C à Arduino UNO Q
- Comment afficher le texte "Hello World" sur les 4 rangées
- Comment afficher du texte, des entiers, des flottants et des nombres hexadécimaux sur le LCD
- Comment créer et afficher des caractères personnalisés sur le LCD
- Comment faire défiler du texte sur l'écran LCD
- Comment contrôler le rétroéclairage du LCD
- Comment utiliser les modes curseur et clignotement
- Comment contrôler le LCD à distance depuis Linux via la programmation Bridge
- Comment contrôler le LCD à distance depuis Telegram via la programmation Bridge
Matériel Requis
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
Note d'achat: Une autre option consiste à créer l'écran LCD I2C en associant LCD 1602 Display et PCF8574 I2C Adapter Module.
À propos du LCD I2C 20x4
Le LCD 20x4 I2C possède 20 colonnes et 4 rangées — deux fois plus de rangées que le 16x2, ce qui le rend utile pour les tableaux de bord, les menus et les affichages d'état multi-lignes. Comme le 16x2, il utilise un adaptateur I2C pour une connexion simple à 4 fils.
Brochage du LCD
Le LCD I2C possède quatre broches :
- GND — connecter à GND
- VCC — connecter à 5V
- SDA — signal de données I2C
- SCL — signal d'horloge I2C
Coordonnées du LCD
Le LCD I2C 20x4 possède 20 colonnes et 4 rangées, numérotées à partir de 0.
Schéma de Câblage
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
| Broche LCD I2C | Broche Arduino UNO Q |
|---|---|
| GND | GND |
| VCC | 5V |
| SDA | SDA |
| SCL | SCL |
※ Note:
L'adresse I2C peut varier selon le fabricant. Nous utilisons 0x27 tel que spécifié par DIYables. Si 0x27 ne fonctionne pas, essayez 0x3F.
Comment Programmer le LCD I2C 20x4
La bibliothèque DIYables_LCD_I2C fonctionne aussi bien pour le 16x2 que pour le 20x4 — il suffit de changer le nombre de colonnes et de rangées.
- Créer l'objet LCD pour le 20x4 :
DIYables_LCD_I2C lcd(0x27, 20, 4); // I2C address 0x27, 20 columns, 4 rows
- Initialiser dans setup() :
lcd.init();
lcd.backlight();
- Déplacer le curseur et afficher (rangées 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");
Consultez le Arduino UNO Q - LCD I2C pour des fonctionnalités supplémentaires telles que les caractères personnalisés et les conseils de dépannage.
Code Arduino UNO Q — Hello World sur LCD 20x4
L'Arduino UNO Q possède deux processeurs : le MCU STM32 (gère le contrôle matériel en temps réel) et le MPU Qualcomm (exécute Debian Linux). Dans cette section, seul le MCU STM32 est programmé — le côté Linux reste inactif. Une section ultérieure montrera comment les deux processeurs travaillent ensemble.
Le sketch ci-dessous affiche du texte sur les quatre rangées du LCD.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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() {}
Étapes Rapides
- Première fois avec Arduino UNO Q ? Suivez le tutoriel Démarrer avec Arduino UNO Q pour préparer votre environnement de développement avant de continuer.
- Câbler le LCD : Connectez VCC→5V, GND→GND, SDA→SDA, SCL→SCL.
- Connecter : Branchez l'Arduino UNO Q à votre ordinateur avec un câble USB-C.
- Ouvrir Arduino App Lab : Lancez Arduino App Lab et attendez qu'il détecte votre Arduino UNO Q.
- Créer une nouvelle application : Cliquez sur le bouton Create New App.
- Donnez un nom à l'application, par exemple : DIYables_LCD_20x4
- Cliquez sur Create pour confirmer.
- Vous verrez un ensemble de dossiers et fichiers générés dans votre nouvelle application.
- Trouvez le fichier sketch/sketch.ino — c'est là que vous collerez le sketch MCU.
Coller le sketch : Copiez le code MCU ci-dessus et collez-le dans le fichier sketch.
- 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
- Téléverser : Cliquez sur le bouton Run dans Arduino App Lab pour compiler et téléverser vers le STM32.
Regardez le LCD — les quatre rangées affichent du texte : "Hello, World!", "Arduino UNO Q", "LCD 20x4 I2C" et "DIYables.io" !
※ Note:
Si le LCD n'affiche rien ou seulement des carrés noirs, ajustez le potentiomètre de contraste sur l'adaptateur I2C. Consultez Dépannage LCD I2C pour plus d'aide.
Code Arduino UNO Q — Afficher du Texte et des Nombres sur LCD 20x4
Cet exemple montre comment afficher une chaîne de texte brut, un entier, un flottant et un nombre hexadécimal — un sur chaque rangée.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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() {}
Étapes Rapides
- Copiez le code ci-dessus et collez-le dans sketch/sketch.ino.
- Cliquez sur le bouton Run dans Arduino App Lab.
Le LCD affiche du texte sur la rangée 0, un entier sur la rangée 1, un flottant sur la rangée 2 et un nombre hexadécimal sur la rangée 3.
Référence des Fonctions LCD Utiles
Référence rapide pour les fonctions DIYables_LCD_I2C couramment utilisées :
- lcd.init() — initialiser le LCD
- lcd.backlight() — allumer le rétroéclairage
- lcd.noBacklight() — éteindre le rétroéclairage
- lcd.setCursor(col, row) — déplacer le curseur à la colonne *col*, rangée *row* (les deux basés sur 0)
- lcd.print("text") — afficher une chaîne à la position actuelle du curseur
- lcd.print(number) — afficher un entier
- lcd.print(number, HEX) — afficher un entier en hexadécimal
- lcd.print(floatVal, decimals) — afficher un flottant avec le nombre de décimales spécifié
- lcd.clear() — effacer l'affichage et déplacer le curseur en (0, 0)
- lcd.home() — déplacer le curseur en (0, 0) sans effacer
- lcd.createChar(id, array) — enregistrer un caractère personnalisé (id 0 à 7)
- lcd.write((byte)id) — afficher un caractère personnalisé enregistré
- lcd.scrollDisplayLeft() — décaler tout le contenu d'une colonne vers la gauche
- lcd.scrollDisplayRight() — décaler tout le contenu d'une colonne vers la droite
- lcd.cursor() — afficher le curseur souligné
- lcd.noCursor() — masquer le curseur
- lcd.blink() — afficher le curseur bloc clignotant
- lcd.noBlink() — arrêter le curseur bloc clignotant
Code Arduino UNO Q — Caractères Personnalisés sur LCD 20x4
Le LCD 20x4 peut stocker jusqu'à 8 caractères personnalisés (IDs 0 à 7). Chaque caractère est défini comme un bitmap de 8 lignes × 5 colonnes stocké dans un tableau d'octets. Définissez les tableaux, enregistrez-les avec lcd.createChar(), puis affichez-les avec lcd.write().
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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() {}
Étapes Rapides
- Copiez le code ci-dessus et collez-le dans sketch/sketch.ino.
- Cliquez sur le bouton Run dans Arduino App Lab.
Le LCD affiche quatre rangées, chacune étiquetée avec le caractère personnalisé affiché à la fin : cœur, souriant, note de musique et flèche.
※ Note:
Pour concevoir vos propres caractères, utilisez le Générateur de Caractères Personnalisés LCD — il vous permet de dessiner le motif de pixels et génère le tableau d'octets prêt à utiliser dans votre code.
Code Arduino UNO Q — Défilement de Texte sur LCD 20x4
scrollDisplayLeft() et scrollDisplayRight() décalent tout le contenu de l'affichage d'une colonne par appel — toutes les quatre rangées se déplacent ensemble. Utilisez une boucle avec un court délai pour créer un effet de défilement fluide.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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() {}
Étapes Rapides
- Copiez le code ci-dessus et collez-le dans sketch/sketch.ino.
- Cliquez sur le bouton Run dans Arduino App Lab.
Le contenu du LCD glisse vers la gauche de 20 pas, fait une pause, puis glisse vers la droite de 20 pas pour revenir à la position d'origine.
Code Arduino UNO Q — Contrôle du Rétroéclairage sur LCD 20x4
Utilisez lcd.backlight() pour allumer la LED de rétroéclairage de l'adaptateur I2C et lcd.noBacklight() pour l'éteindre. Cette démo fait défiler le cycle : allumé → éteint → allumé → motif de clignotement.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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() {}
Étapes Rapides
- Copiez le code ci-dessus et collez-le dans sketch/sketch.ino.
- Cliquez sur le bouton Run dans Arduino App Lab.
Observez le rétroéclairage du LCD s'allumer, puis s'éteindre, puis se rallumer, et finalement clignoter cinq fois.
Code Arduino UNO Q — Curseur et Clignotement sur LCD 20x4
Le LCD supporte deux styles de curseur : un curseur souligné (lcd.cursor()) et un curseur bloc clignotant (lcd.blink()). Ils peuvent être affichés individuellement ou ensemble.
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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() {}
Étapes Rapides
- Copiez le code ci-dessus et collez-le dans sketch/sketch.ino.
- Cliquez sur le bouton Run dans Arduino App Lab.
Le LCD fait défiler le cycle : curseur souligné visible → masqué → curseur bloc clignotant → arrêté → curseur et clignotement ensemble → les deux éteints.
Programmation Bridge Linux + MCU
L'Arduino UNO Q possède deux processeurs qui travaillent ensemble : le MPU (Qualcomm, exécute Debian Linux) et le MCU (STM32, exécute Zephyr OS avec votre sketch Arduino). Ils communiquent via RPC grâce à la bibliothèque Arduino_RouterBridge — jamais via des ports série bruts.
- Le LCD est connecté au MCU (STM32) — via I2C (SDA/SCL). Seul le MCU peut y écrire directement.
- Le MPU ne peut pas contrôler le LCD directement — il appelle des fonctions MCU comme Bridge.call("set_line1", "text") pour mettre à jour chaque rangée.
- Le MPU dispose du Wi-Fi — comme le MPU exécute Debian Linux complet avec Wi-Fi, il peut recevoir des commandes Telegram et afficher n'importe quel message sur le LCD à distance.
- Communication : Bridge.call() du côté Linux invoque les fonctions Bridge.provide_safe() du côté MCU (car les écritures LCD sont des appels d'API matérielle).
- ⚠️ Réservé : /dev/ttyHS1 (Linux) et Serial1 (MCU) sont utilisés par le routeur Arduino — ne les ouvrez jamais directement.
En résumé : Le MPU envoie du texte via Bridge → le MCU écrit sur la rangée LCD → le MCU affiche le résultat sur le Moniteur.
Sketch MCU — LCD 20x4 avec Bridge et sortie Moniteur :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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() {}
Script Python (Arduino App Lab) — afficher du texte sur le LCD 20x4 depuis Linux :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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)
Étapes Rapides
- Créer une nouvelle application : Ouvrez Arduino App Lab, cliquez sur Create New App, nommez-la DIYables_LCD_20x4_Bridge, et cliquez sur Create.
- Coller le sketch MCU : Copiez le code MCU Bridge ci-dessus et collez-le dans sketch/sketch.ino.
- Coller le script Python : Copiez le code Python ci-dessus et collez-le dans le fichier Python de l'application.
- Exécuter l'application : Cliquez sur le bouton Run — le côté Python met à jour les quatre rangées du LCD, puis efface et met à jour à nouveau.
Sortie de la Console App Lab
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:
Intégration Telegram
Contrôlez votre LCD 20x4 à distance — envoyez n'importe quel texte sur n'importe quelle rangée depuis n'importe où via Telegram.
Si vous n'avez pas encore de bot Telegram, consultez Arduino UNO Q - Bot Telegram pour obtenir votre token de bot avant de continuer.
Sketch MCU : Conservez le même sketch MCU de la section Bridge précédente — aucune modification nécessaire. Assurez-vous qu'il est déjà téléversé et en cours d'exécution sur le STM32 avant de continuer.
Script Python (Arduino App Lab) — bot Telegram pour LCD 20x4 :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/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)
- Remarque : Remplacez YOUR_BOT_TOKEN par le token obtenu depuis @BotFather sur Telegram.
- Envoyez /row1 Bonjour — affiche "Bonjour" sur la rangée 1.
- Envoyez /row2 Monde — affiche "Monde" sur la rangée 2.
- Envoyez /clear — efface tout le LCD.
- Envoyez /status — retourne le contenu actuel des 4 rangées.
Étapes Rapides
- Téléverser le sketch MCU : Utilisez le sketch MCU Bridge de la section précédente.
- Coller le script Telegram : Copiez le code Python ci-dessus dans l'onglet Python.
- Définir votre token : Remplacez YOUR_BOT_TOKEN par votre vrai token de bot.
- Exécuter l'application : Cliquez sur Run — le bot écoute les commandes Telegram.
- Tester : Envoyez /row1 Arduino UNO Q — ce texte devrait apparaître sur la première rangée du LCD.
Sortie de la Console App Lab
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
Intégration d'OpenClaw
Vous pouvez adapter OpenClaw à ce tutoriel en vous référant aux instructions du tutoriel Arduino UNO Q - OpenClaw.
Idées d'Application/Projets
- Tableau de bord capteurs à 4 rangées : Afficher simultanément la température, l'humidité, la pression et le niveau de batterie sur les quatre rangées
- Tableau de statut réseau : Afficher l'adresse IP, les appareils connectés, le temps de fonctionnement et le dernier événement sur des rangées dédiées
- Affichage d'équipement de laboratoire : Utiliser le 20x4 pour afficher les lectures de capteurs multi-canaux dans un format compact
- Tableau de minuterie à rebours : Afficher une minuterie en grand format sur les 4 rangées pour une lecture facile à travers une pièce
- Tableau d'affichage distant : Utiliser Telegram pour pousser des annonces à 4 lignes vers un LCD sur un mur ou un bureau
Défiez-vous
- Facile : Modifier la réponse /status pour formater les 4 rangées comme Rangée 1 : texte | Rangée 2 : texte | Rangée 3 : texte | Rangée 4 : texte dans un seul message
- Moyen : Ajouter une commande /display <text> qui enveloppe automatiquement le texte long sur jusqu'à 4 rangées de 20 caractères chacune
- Avancé : Implémenter un défileur en utilisant lcd.scrollDisplayLeft() qui affiche un long message de Telegram sur les 4 rangées