Arduino UNO Q - LCD I2C
Ce tutoriel vous montre comment utiliser un écran LCD I2C 16x2 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 LCD I2C à Arduino UNO Q
- Comment afficher le texte "Hello World" sur les deux 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 16x2
Le LCD I2C combine un panneau LCD standard 16x2 avec un module adaptateur I2C. L'interface I2C réduit le câblage à seulement 4 fils — bien plus simple qu'une connexion LCD parallèle.
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 16x2 possède 16 colonnes et 2 rangées, avec colonnes et 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 du LCD peut varier selon le fabricant. Dans ce tutoriel, nous utilisons 0x27, qui est la valeur par défaut pour les modules DIYables.
Comment Programmer le LCD I2C
La bibliothèque DIYables_LCD_I2C facilite le contrôle du LCD.
- Inclure la bibliothèque :
#include <DIYables_LCD_I2C.h>
- Créer un objet LCD avec l'adresse I2C, le nombre de colonnes et de rangées :
DIYables_LCD_I2C lcd(0x27, 16, 2); // I2C address 0x27, 16 columns, 2 rows
- Initialiser le LCD dans setup() :
lcd.init(); // Initialize the LCD
lcd.backlight(); // Turn on the backlight
- Déplacer le curseur à une position (colonne, rangée) :
lcd.setCursor(column_index, row_index);
- Afficher du texte à la position actuelle du curseur :
lcd.print("Hello World!");
Consultez la section "Aller plus loin avec le LCD" pour le défilement, les caractères personnalisés et plus encore.
※ Note:
L'adresse I2C peut varier selon le fabricant. Nous utilisons 0x27 tel que spécifié par DIYables.
Code Arduino UNO Q — Hello World sur LCD I2C
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 deux 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-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() {}
É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_I2C
- 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 — la rangée 0 affiche "Hello, World!" et la rangée 1 affiche "Arduino UNO Q" !
※ Note:
Si le LCD n'affiche rien ou seulement des carrés noirs, ajustez le potentiomètre de contraste au dos du module I2C à l'aide d'un petit tournevis. Consultez Dépannage sur LCD I2C pour plus d'aide.
Code Arduino UNO Q — Afficher du Texte et des Nombres sur LCD I2C
Cet exemple montre comment afficher une chaîne de texte brut, un entier, un flottant et un nombre hexadécimal sur le 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-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() {}
É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 d'abord du texte et un entier, puis après 3 secondes efface et affiche un flottant et un nombre hexadécimal.
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 I2C
lcd.print() fonctionne uniquement avec les caractères ASCII. Pour afficher un symbole spécial (par exemple, cœur, flèche), définissez un caractère personnalisé en utilisant 8 octets de données de pixels. Une cellule de caractère LCD 16x2 est de 8 lignes × 5 colonnes de pixels — vous pouvez stocker jusqu'à 8 caractères personnalisés (IDs 0 à 7).
Utilisez le générateur de caractères ci-dessous pour concevoir votre caractère et obtenir le code binaire :
Click on each pixel to select/deselect
Copy below custom character code
Replace the customChar[8] in the below code
/*
* 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-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() {}
É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 symboles personnalisés : cœur, souriant, note de musique et flèche — deux par rangée.
※ 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. Vous pouvez également utiliser le générateur interactif ci-dessus.
Code Arduino UNO Q — Défilement de Texte sur LCD I2C
scrollDisplayLeft() et scrollDisplayRight() décalent tout le contenu de l'affichage d'une colonne par appel — les deux 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-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() {}
É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 16 pas, fait une pause, puis glisse vers la droite de 16 pas pour revenir à la position d'origine.
Code Arduino UNO Q — Contrôle du Rétroéclairage sur LCD I2C
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-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() {}
É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 I2C
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-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() {}
É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.
Dépannage sur LCD I2C
- LCD n'affiche rien / rétroéclairage éteint — Vérifiez VCC→5V et GND. Assurez-vous que l'appel lcd.backlight() est dans setup().
- LCD affiche des carrés noirs sur les deux rangées — Le contraste est trop élevé. Tournez le potentiomètre sur l'adaptateur I2C pour réduire le contraste.
- LCD affiche un texte faible/invisible — Le contraste est trop faible. Augmentez-le via le potentiomètre.
- Caractères incorrects affichés — L'adresse I2C peut être incorrecte. Essayez 0x3F si 0x27 ne fonctionne pas, ou exécutez un sketch de scanner I2C pour trouver l'adresse.
- Le sketch est téléversé mais le LCD reste vide — Vérifiez que les connexions SDA et SCL ne sont pas inversées.
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 le bus I2C (SDA/SCL). Seul le MCU peut piloter directement le LCD.
- Le MPU ne peut pas contrôler le LCD directement — il appelle des fonctions MCU via Bridge.call("set_line1", "text") qui met à jour le LCD et retourne le résultat.
- 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 Telegram → le MPU appelle Bridge → le MCU met à jour le LCD → le MCU renvoie le résultat au MPU.
Sketch MCU — LCD I2C 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-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() {}
Script Python (Arduino App Lab) — afficher du texte sur le LCD 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-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)
- Remarque : Assurez-vous que Bridge.begin() est appelé dans le sketch MCU et que le sketch est téléversé avant d'exécuter le script Python.
- ⚠️ Avertissement : N'ouvrez jamais directement /dev/ttyHS1 (sur Linux) ou n'utilisez jamais Serial1 (sur le MCU) — ces ports sont réservés par le routeur Arduino.
Étapes Rapides
- Créer une nouvelle application : Ouvrez Arduino App Lab, cliquez sur Create New App, nommez-la DIYables_LCD_I2C_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 le LCD toutes les quelques secondes.
Sortie de la Console App Lab
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
Intégration Telegram
Envoyez n'importe quel message sur votre LCD depuis n'importe où dans le monde 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 contrôler le 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-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)
- Remarque : Remplacez YOUR_BOT_TOKEN par le token obtenu depuis @BotFather sur Telegram.
- Envoyez /display Hello World — le texte apparaît sur le LCD.
- Envoyez /clear — l'écran LCD est effacé.
- Envoyez /status — le bot répond avec le contenu actuel du LCD.
Étapes Rapides
- Téléverser le sketch MCU : Utilisez le sketch MCU Bridge de la section précédente (téléversez-le d'abord si ce n'est pas déjà fait).
- Coller le script Telegram : Copiez le code Python ci-dessus dans l'onglet Python de votre application dans Arduino App Lab.
- Définir votre token : Remplacez YOUR_BOT_TOKEN dans le script par votre vrai token de bot.
- Exécuter l'application : Cliquez sur Run — le bot commence à écouter les commandes Telegram.
- Tester : Envoyez /display Arduino UNO Q — le LCD devrait afficher le texte. Envoyez /clear pour l'effacer.
Sortie de la Console App Lab
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
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 d'affichage IoT : Utilisez Telegram pour pousser des annonces vers un LCD sur un mur — aucun ordinateur à proximité n'est nécessaire
- Tableau de bord capteurs : Afficher la température, l'humidité ou d'autres valeurs de capteurs du côté MPU en temps réel
- Affichage d'alarme de porte : Lorsqu'un capteur de mouvement se déclenche, afficher "MOUVEMENT DÉTECTÉ" sur le LCD et envoyer une alerte Telegram
- Station météo Wi-Fi : Récupérer les données météo depuis une API sur le MPU et faire défiler les prévisions sur le LCD
- Minuterie à rebours : Envoyer /timer 60 via Telegram et le LCD compte à rebours les secondes en utilisant la boucle MCU
Défiez-vous
- Facile : Modifier le bot Telegram pour prendre en charge les commandes /line1 <text> et /line2 <text> pour définir chaque rangée LCD indépendamment
- Moyen : Ajouter une commande /scroll <text> qui fait défiler le texte long sur le LCD (utiliser lcd.scrollDisplayLeft() dans une boucle)
- Avancé : Afficher des données de capteurs en direct (température depuis un DHT22) sur le LCD tout en maintenant les commandes Telegram réactives grâce à un minuteur de mise à jour non bloquant