Arduino UNO Q - Shield LCD Clavier
Obtenir des entrées utilisateur et afficher des retours est une compétence fondamentale dans tout projet Arduino, et le shield LCD Clavier la rend simple sur Arduino UNO Q. Ce shield tout-en-un s'empile directement sur votre Arduino UNO Q, vous offrant un écran LCD 16×2 et cinq boutons d'entrée sur une seule carte compacte — aucun câblage supplémentaire requis !
Dans ce tutoriel, vous apprendrez :
- Ce qu'est le shield LCD Clavier et comment il fonctionne
- Comment câbler (empiler) le shield LCD Clavier sur Arduino UNO Q
- Comment programmer le MCU (code Arduino C/C++) sur Arduino UNO Q pour lire directement les boutons et contrôler le LCD
- Comment programmer le côté Linux (Python) et le côté MCU (code Arduino C/C++) pour que le côté Linux interagisse avec le côté MCU pour contrôler le shield LCD Clavier
- Comment utiliser Telegram pour envoyer des messages à Arduino UNO Q afin d'afficher des messages sur le LCD ou lire les états des boutons
- Comment utiliser OpenClaw sur Arduino UNO Q pour contrôler le shield LCD Clavier
- Comment lire quel bouton est pressé et afficher le résultat sur l'écran LCD
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.
À propos du Shield LCD Clavier
Le shield LCD Clavier est un shield Arduino plug-and-play qui combine un écran LCD 16×2 avec cinq boutons d'entrée sur une seule carte.
- Affichage : LCD 16×2 — affiche 2 rangées de 16 caractères, piloté par la bibliothèque LiquidCrystal
- Boutons : 5 boutons d'entrée (Droite, Haut, Bas, Gauche, Sélect) — tous connectés à une seule broche analogique (A0) via un diviseur résistif
- Réinitialisation : 1 bouton de réinitialisation dédié pour redémarrer l'Arduino UNO Q
- Contraste : Potentiomètre intégré (bouton) pour ajuster le contraste du LCD
- Format : Shield Arduino standard — s'empile directement sur les broches d'Arduino UNO Q, aucun câblage supplémentaire nécessaire
- Pourquoi c'est idéal pour les débutants : Branchez et utilisez — pas de soudure, pas de fils de connexion, et vous obtenez un retour visuel immédiat
Brochage
Le shield LCD Clavier se connecte à Arduino UNO Q via ses connecteurs de shield. Voici comment chaque broche est mappée :
| Broche du Shield | Fonction | Broche Arduino UNO Q |
|---|---|---|
| DB4 | Données LCD | 4 |
| DB5 | Données LCD | 5 |
| DB6 | Données LCD | 6 |
| DB7 | Données LCD | 7 |
| RS | Sélection de registre | 8 |
| E | Activation | 9 |
| Analogique A0 | Entrée bouton | A0 |
- Bouton de réinitialisation : Redémarre l'Arduino UNO Q lorsqu'il est pressé
- Potentiomètre (bouton) : Ajuste le contraste du LCD — tournez-le si l'écran semble vide ou trop sombre
※ Note:
Note de compatibilité pour Arduino UNO Q :
- Écran LCD : Fonctionne parfaitement — la bibliothèque LiquidCrystal pilote toutes les fonctions d'affichage 16×2 sans problème.
- Boutons — important : Les boutons sont tous câblés sur une seule broche analogique (A0) via un diviseur résistif. Le shield a été conçu pour un ADC 5V, mais le STM32 sur Arduino UNO Q utilise une référence 3,3V avec un ADC 12 bits (0–4095). Différents fabricants de shields utilisent des valeurs de résistances différentes, donc la lecture ADC pour chaque bouton varie entre les shields. Vous devez calibrer les seuils pour votre shield spécifique (voir la section Dépannage) — sinon les boutons peuvent être détectés incorrectement (par exemple, GAUCHE détecté comme BAS).
- Bouton SÉLECT : Dépend de votre variante de shield. Sur certains shields, SÉLECT produit une tension supérieure à 3,3V, ce qui se coupe à 4095 (identique à "aucune touche") — SÉLECT ne peut pas être détecté. Sur d'autres shields, SÉLECT produit une tension inférieure à 3,3V et peut être détecté. Calibrez d'abord pour le découvrir.
Le Shield LCD Clavier de DIYables utilisé dans ce tutoriel fonctionne bien avec Arduino UNO Q pour les cinq boutons, y compris SÉLECT.
Schéma de Câblage
Aucun câblage nécessaire — il suffit d'empiler le shield LCD Clavier directement sur votre Arduino UNO Q et les broches s'alignent automatiquement.
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
- Remarque : Assurez-vous que le shield est bien enfoncé pour que toutes les broches soient en contact solide.
Code MCU (Sketch Arduino Direct)
L'Arduino UNO Q dispose de deux processeurs — comme deux cerveaux dans une seule carte : le MCU STM32 (gère le contrôle matériel en temps réel) et le MPU Qualcomm (exécute Linux). Dans cette section, nous programmons uniquement le MCU STM32 en Arduino C/C++ — le côté Linux reste inactif. Dans une section ultérieure, nous programmerons les deux processeurs et les ferons interagir.
Voici le sketch Arduino qui s'exécute directement sur le MCU STM32 pour détecter les pressions de boutons et afficher les résultats sur le LCD.
- Initialise le LCD 16×2 en utilisant la bibliothèque LiquidCrystal
- Lit la valeur analogique de A0 pour détecter quel bouton est pressé
- Affiche le nom du bouton pressé sur le LCD en temps réel
- Rapporte les événements de bouton à la console App Lab via Monitor.println()
/*
* 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-keypad-shield
*/
#include <LiquidCrystal.h>#include "Arduino_RouterBridge.h"
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
void setup() {
analogReadResolution(12); // STM32 on UNO Q: 12-bit ADC (0-4095)
Monitor.begin();
lcd.begin(16, 2);
lcd.print("Hello!");
delay(3000);
}
void loop() {
int key = analogRead(A0);
// Shield resistor ladder outputs up to 5V, but STM32 ADC reference is 3.3V (12-bit, 0-4095).
// ADC values VARY between shield manufacturers — run the calibration sketch first!
// Calibrated values: RIGHT~0, UP~590, DOWN~1500, LEFT~2390, SELECT~3733, NONE~4095
// Thresholds are midpoints between adjacent button values.
lcd.clear();
if (key < 295) {
lcd.print("RIGHT");
Monitor.println("Button: RIGHT");
} else if (key < 1045) {
lcd.print("UP");
Monitor.println("Button: UP");
} else if (key < 1945) {
lcd.print("DOWN");
Monitor.println("Button: DOWN");
} else if (key < 3062) {
lcd.print("LEFT");
Monitor.println("Button: LEFT");
} else if (key < 3914) {
lcd.print("SELECT");
Monitor.println("Button: SELECT");
} else {
lcd.print("Press key!");
Monitor.println("Button: NONE");
}
delay(200);
}
É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.
- Empiler le shield : Appuyez fermement le shield LCD Clavier sur votre Arduino UNO Q — toutes les broches doivent s'aligner et se mettre en place complètement.
- 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 — cela peut prendre plusieurs minutes au premier lancement.
- Créer une nouvelle application : Cliquez sur le bouton Create New App.
- Donnez un nom à l'application, par exemple : DIYables_LCD_Keypad_Shield
- 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 ce fichier sketch. Gardez les autres fichiers par défaut.
- Install the library: Click the Add sketch library button (the open book icon with a + sign) in the left sidebar.
- Search for LiquidCrystal created by Arduino, Adafruit 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 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
- Téléverser : Cliquez sur le bouton Run dans Arduino App Lab pour compiler et téléverser vers le STM32.
- Tester : Appuyez sur chaque bouton (Droite, Haut, Bas, Gauche, Sélect) un par un et observez le LCD se mettre à jour.
- Écran vide ? Tournez le bouton de contraste sur le shield jusqu'à ce que le texte devienne clairement visible.
- Conseil Pro : Appuyez sur le bouton de réinitialisation du shield pour redémarrer votre sketch sans débrancher le câble USB-C.
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-28 10:01:10] Button: NONE
[2026-04-28 10:01:13] Button: RIGHT
[2026-04-28 10:01:16] Button: UP
[2026-04-28 10:01:19] Button: DOWN
[2026-04-28 10:01:22] Button: LEFT
[2026-04-28 10:01:25] Button: SELECT
Bonus : Code Plus Propre
Vous voulez que votre code soit plus professionnel ? Voici une version avancée avec des fonctions bien organisées :
/*
* 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-keypad-shield
*/
#include <LiquidCrystal.h>
// Define constants for key representations
const int KEY_RIGHT = 0;
const int KEY_UP = 1;
const int KEY_DOWN = 2;
const int KEY_LEFT = 3;
const int KEY_SELECT = 4;
const int KEY_NONE = 5;
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
int getKey() {
int analogValue = analogRead(A0);
// Shield resistor ladder outputs up to 5V, but STM32 ADC reference is 3.3V (12-bit, 0-4095).
// ADC values VARY between shield manufacturers — run the calibration sketch first!
// Calibrated values: RIGHT~0, UP~590, DOWN~1500, LEFT~2390, SELECT~3733, NONE~4095
// Thresholds are midpoints between adjacent button values.
if (analogValue < 295) return KEY_RIGHT;
else if (analogValue < 1045) return KEY_UP;
else if (analogValue < 1945) return KEY_DOWN;
else if (analogValue < 3062) return KEY_LEFT;
else if (analogValue < 3914) return KEY_SELECT;
else return KEY_NONE;
}
void setup() {
analogReadResolution(12); // STM32 on UNO Q: 12-bit ADC (0-4095)
lcd.begin(16, 2);
lcd.print("Hello!");
delay(3000);
}
void loop() {
lcd.clear();
int key = getKey();
switch (key) {
case KEY_RIGHT:
lcd.print("RIGHT");
break;
case KEY_UP:
lcd.print("UP");
break;
case KEY_DOWN:
lcd.print("DOWN");
break;
case KEY_LEFT:
lcd.print("LEFT");
break;
case KEY_SELECT:
lcd.print("SELECT");
break;
default:
lcd.print("Press key!");
break;
}
delay(200);
}
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.
- MPU (côté Linux) : Exécute Python pour interroger l'état des boutons et envoyer du texte au LCD
- MCU (côté STM32) : Gère la lecture des boutons en temps réel et les mises à jour du LCD
- Communication : Bridge.call() du côté Linux invoque les fonctions Bridge.provide() du côté MCU
- ⚠️ Réservé : /dev/ttyHS1 (Linux) et Serial1 (MCU) sont utilisés par le routeur Arduino — ne les ouvrez jamais directement
Sketch MCU — expose la lecture des boutons et l'écriture LCD au côté 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-keypad-shield
*/
#include "Arduino_RouterBridge.h"
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
void setup() {
analogReadResolution(12); // STM32 on UNO Q: use 12-bit ADC (0-4095)
lcd.begin(16, 2);
lcd.print("Bridge ready...");
Bridge.begin();
Monitor.begin();
Bridge.provide("read_button", read_button);
Bridge.provide("set_lcd_line1", set_lcd_line1);
Bridge.provide("set_lcd_line2", set_lcd_line2);
Monitor.println("MCU Bridge ready.");
}
void loop() {}
int read_button() {
int val = analogRead(A0);
// Shield outputs up to 5V; STM32 ADC reference is 3.3V (12-bit, 0-4095).
// ADC values VARY between shield manufacturers — run the calibration sketch first!
// Calibrated values: RIGHT~0, UP~590, DOWN~1500, LEFT~2390, SELECT~3733, NONE~4095
// Thresholds are midpoints between adjacent button values.
if (val < 295) return 1; // RIGHT
if (val < 1045) return 2; // UP
if (val < 1945) return 3; // DOWN
if (val < 3062) return 4; // LEFT
if (val < 3914) return 5; // SELECT
return 0; // NONE — no button pressed
}
void set_lcd_line1(String text) {
lcd.setCursor(0, 0);
lcd.print(" "); // clear line
lcd.setCursor(0, 0);
lcd.print(text);
}
void set_lcd_line2(String text) {
lcd.setCursor(0, 1);
lcd.print(" "); // clear line
lcd.setCursor(0, 1);
lcd.print(text);
}
Script Python (Arduino App Lab) — interroger l'état des boutons et mettre à jour 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-keypad-shield
*/
from arduino.app_utils import *
import time
BUTTON_NAMES = {0: "NONE", 1: "RIGHT", 2: "UP", 3: "DOWN", 4: "LEFT", 5: "SELECT"}
def loop():
btn = Bridge.call("read_button")
name = BUTTON_NAMES.get(btn, "UNKNOWN")
Bridge.call("set_lcd_line1", "Button pressed:")
Bridge.call("set_lcd_line2", name)
print(f"Button: {name}")
time.sleep(0.5)
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 du côté Linux.
- ⚠️ Avertissement : N'ouvrez jamais directement /dev/ttyHS1 (sur Linux) ou n'utilisez jamais Serial1 (sur le MCU) dans votre code — ceux-ci sont réservés par le routeur Arduino et y accéder cassera le Bridge.
Étapes Rapides
- Téléverser le sketch MCU : Ouvrez Arduino App Lab, créez une nouvelle application, collez le sketch MCU ci-dessus dans l'onglet Sketch, et cliquez sur Run.
- Ajouter le script Python : Collez le code Python ci-dessus dans l'onglet Python de la même application.
- Exécuter l'application : Cliquez sur Run — le côté Linux commencera à interroger l'état des boutons toutes les 0,5 secondes.
- Appuyer sur les boutons : Appuyez sur l'un des cinq boutons et observez le LCD et la console App Lab se mettre à jour en temps réel.
- Conseil Pro : Augmentez la valeur de time.sleep() pour réduire la fréquence d'interrogation et diminuer l'utilisation du CPU du côté Linux.
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
MCU Bridge ready.
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-28 10:05:01] Button: NONE
[2026-04-28 10:05:02] Button: NONE
[2026-04-28 10:05:02] Button: UP
[2026-04-28 10:05:03] Button: UP
[2026-04-28 10:05:04] Button: LEFT
[2026-04-28 10:05:04] Button: NONE
Intégration Telegram
Vous pouvez contrôler votre shield LCD Clavier Arduino UNO Q à distance via Telegram — afficher n'importe quel message sur l'écran LCD ou vérifier quel bouton est pressé, depuis n'importe où.
Si vous n'avez pas encore de bot Telegram, consultez Arduino UNO Q - Bot Telegram pour obtenir votre token de bot avant de continuer.
Cette section couvre :
- L'exécution d'un script Python du côté Linux de l'Arduino UNO Q pour écouter les messages Telegram
- Le transfert de commandes de Telegram vers le côté MCU pour mettre à jour le LCD ou lire l'état des boutons
- Le renvoi du résultat MCU comme réponse Telegram
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 shield LCD Clavier :
/*
* 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-keypad-shield
*/
from arduino.app_utils import *
import requests
import time
BOT_TOKEN = "YOUR_BOT_TOKEN"
API_URL = f"https://api.telegram.org/bot{BOT_TOKEN}"
BUTTON_NAMES = {0: "NONE", 1: "RIGHT", 2: "UP", 3: "DOWN", 4: "LEFT", 5: "SELECT"}
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("/lcd "):
content = text[5:]
line1 = content[:16]
line2 = content[16:32] if len(content) > 16 else ""
Bridge.call("set_lcd_line1", line1)
Bridge.call("set_lcd_line2", line2)
send_message(chat_id, f"LCD updated: {content}")
elif text == "/button":
btn = Bridge.call("read_button")
name = BUTTON_NAMES.get(btn, "UNKNOWN")
send_message(chat_id, f"Button pressed: {name}")
else:
send_message(chat_id, "Commands:\n/lcd <text> — display text on LCD\n/button — read current button state")
time.sleep(1)
App.run(user_loop=loop)
- Remarque : Remplacez YOUR_BOT_TOKEN par le token obtenu depuis @BotFather sur Telegram.
- Envoyez /lcd Bonjour UNO Q ! pour afficher un message sur l'écran LCD.
- Envoyez /button pour vérifier quel bouton est actuellement pressé sur le shield.
Étapes Rapides
- Créer un bot Telegram : Envoyez un message à @BotFather sur Telegram, envoyez /newbot, suivez les instructions et copiez votre token de bot.
- 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 messages Telegram immédiatement.
- Tester : Envoyez /lcd Bonjour ! à votre bot et observez le texte apparaître sur le LCD.
- Conseil Pro : Utilisez /button pour vérifier à distance quel bouton du shield un utilisateur presse — idéal pour le débogage à distance ou les manettes de jeu.
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-28 10:10:01] Telegram: /lcd Hello UNO Q!
[2026-04-28 10:10:01] LCD updated: Hello UNO Q!
[2026-04-28 10:10:18] Telegram: /button
[2026-04-28 10:10:18] Button pressed: SELECT
[2026-04-28 10:10:35] Telegram: /lcd Arduino is fun
[2026-04-28 10:10:35] LCD updated: Arduino is fun
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
Voici quelques idées de projets amusants que vous pouvez construire avec le shield LCD Clavier et Arduino UNO Q :
- Système piloté par menu : Utilisez les boutons Haut/Bas pour faire défiler les éléments de menu affichés sur le LCD
- Tableau de score numérique : Suivez les scores d'un jeu à deux joueurs, en utilisant le bouton Sélect pour réinitialiser
- Saisie de code PIN : Entrez un code à l'aide des boutons et affichez un retour masqué sur le LCD
- Affichage contrôlé par Telegram : Permettez à n'importe qui d'envoyer des messages à votre Arduino UNO Q pour mettre à jour ce qui est affiché sur le LCD à distance
- Tableau de bord de capteurs distant : Afficher les lectures de température ou d'humidité des capteurs sur le LCD, lisibles et actualisables via Telegram
- Chronomètre simple : Démarrer/Arrêter avec Sélect, réinitialiser avec Gauche, et afficher le temps écoulé sur l'écran 16×2
Besoin de plus d'astuces LCD ? Consultez le tutoriel Arduino LiquidCrystal LCD pour plus d'idées.
Défiez-vous
Essayez ces défis avec votre shield LCD Clavier et Arduino UNO Q pour améliorer vos compétences :
- Facile : Faites en sorte que le LCD affiche un message de bienvenue sur la ligne 1 et mette à jour la ligne 2 avec le nom de chaque bouton au fur et à mesure qu'il est pressé
- Moyen : Construisez un chronomètre — utilisez Sélect pour démarrer/arrêter et Gauche pour réinitialiser, en affichant le temps écoulé sur le LCD mis à jour chaque seconde
- Avancé : Créez un menu multi-niveaux contrôlé par Telegram où les utilisateurs naviguent dans les menus LCD à distance en envoyant des commandes Haut/Bas/Sélect via le bot Telegram
Dépannage
Les boutons sont détectés incorrectement (mauvais nom de bouton affiché) :
Les valeurs ADC des boutons varient selon les fabricants de shields. Le code est pré-calibré pour Arduino UNO Q, mais si votre shield utilise des résistances différentes, vous devez le recalibrer. Téléversez le sketch de calibration ci-dessous, maintenez chaque bouton un à la fois, et notez la valeur ADC affichée sur le LCD et la console App Lab :
/*
* 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-keypad-shield
*/
#include <LiquidCrystal.h>#include "Arduino_RouterBridge.h"
// LCD Keypad Shield — ADC Calibration Sketch
// Upload this sketch, then hold each button one at a time.
// Note the ADC value shown on the LCD and in the App Lab console.
// Use those values to set the correct thresholds in your main sketch.
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
void setup() {
analogReadResolution(12); // STM32 on UNO Q: 12-bit ADC (0-4095)
lcd.begin(16, 2);
lcd.setCursor(0, 0);
lcd.print("Hold each button");
Monitor.begin();
Monitor.println("Hold each button and note the ADC value:");
Monitor.println(" NONE (no key): should be near 4095");
Monitor.println(" RIGHT, UP, DOWN, LEFT, SELECT: record each value");
}
void loop() {
int val = analogRead(A0);
lcd.setCursor(0, 1);
lcd.print("A0: ");
lcd.print(val);
lcd.print(" "); // clear leftover digits
Monitor.println(val);
delay(300);
}
Notez vos résultats :
| Bouton | Votre valeur ADC |
|---|---|
| DROITE | ? |
| HAUT | ? |
| BAS | ? |
| GAUCHE | ? |
| SÉLECT | ? |
| AUCUN | ? |
Ensuite, définissez chaque seuil dans votre sketch au point médian entre deux valeurs de bouton adjacentes. Par exemple, si HAUT = 590 et BAS = 1500, le seuil entre eux est (590 + 1500) / 2 = 1045.
Le bouton SÉLECT ne fonctionne pas :
Certains shields utilisent un diviseur résistif de résistance plus élevée qui pousse la tension SÉLECT au-dessus de 3,3V — la limite ADC du STM32. Dans ce cas, SÉLECT se coupe à 4095 (identique à aucune touche pressée) et ne peut pas être détecté. Utilisez le sketch de calibration pour vérifier : si SÉLECT et AUCUN lisent tous les deux 4095, SÉLECT est inutilisable sur votre shield.
Écran LCD vide ou brouillé :
Tournez le bouton de contraste (potentiomètre) sur le shield jusqu'à ce que le texte devienne clairement visible.