Arduino Mega - LCD I2C
Bienvenue dans ce tutoriel complet Arduino Mega LCD I2C ! Dans ce guide détaillé Arduino Mega LCD I2C, vous découvrirez comment exploiter la puissance des écrans de caractères 16x2 avec la communication I2C pour créer des interfaces informatives et conviviales dans vos projets Arduino Mega.
Les écrans LCD I2C révolutionnent la façon dont nous ajoutons une sortie visuelle aux projets de microcontrôleurs. L'interface "I2C" (Inter-Integrated Circuit) change la donne en réduisant le nombre de broches de 16 broches (en mode parallèle) à seulement 2 fils de communication (SDA et SCL), plus les connexions d'alimentation. Cela rend le LCD I2C parfait pour les projets avec un nombre limité de broches disponibles. Dans ce tutoriel Arduino Mega LCD I2C, nous explorerons tout ce que vous devez savoir pour maîtriser les écrans LCD :
- Comprendre comment fonctionnent les modules LCD I2C et leurs avantages par rapport aux LCD parallèles
- Instructions étape par étape pour connecter correctement un LCD I2C 16x2 à votre microcontrôleur Arduino Mega
- Techniques de programmation pour afficher des messages texte, des nombres et des caractères spéciaux sur le LCD
- Création de caractères et symboles personnalisés en utilisant le générateur de caractères intégré
- Travail avec le positionnement du curseur pour un placement précis du texte sur 16 colonnes et 2 lignes
- Utilisation du contrôle du rétroéclairage pour la visibilité dans différentes conditions d'éclairage
Ce projet d'écran Arduino Mega LCD I2C ouvre des possibilités incroyables ! Créez des affichages de données de capteurs en temps réel, des menus d'interface utilisateur, des indicateurs d'état, des affichages de mesures, des messages défilants, des moniteurs de température/humidité, des minuteurs de compte à rebours, et toute application où un retour visuel améliore l'expérience utilisateur. Le LCD I2C 16x2 est l'une des options d'affichage les plus populaires et polyvalentes pour les projets embarqués !
Matériel requis
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Capteurs DIYables (30 capteurs/écrans) | |
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
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 16x2 est un module d'affichage à cristaux liquides basé sur des caractères qui combine un écran LCD standard de 16 colonnes par 2 lignes avec un adaptateur d'interface I2C intégré (généralement une puce PCF8574). Cet écran compact fournit une interface claire et facile à lire pour afficher du texte, des nombres et des symboles personnalisés dans vos projets embarqués.
Caractéristiques principales :
- Capacité d'affichage : 32 caractères au total (16 colonnes × 2 lignes)
- Taille des caractères : Chaque caractère est formé par une matrice de pixels 5×8 (ou 5×10 pour les grandes polices)
- Communication I2C : Utilise seulement 2 fils (SDA/SCL) au lieu de 16+ broches parallèles
- Contraste ajustable : Potentiomètre intégré à l'arrière pour l'ajustement du contraste
- Contrôle du rétroéclairage : Rétroéclairage LED bleu ou vert (contrôlable par logiciel via I2C)
- Faible nombre de broches : Ne nécessite que 4 broches au total (VCC, GND, SDA, SCL)
Avantages du I2C :
L'interface I2C est une amélioration massive par rapport à la connexion parallèle traditionnelle. Elle économise 10+ broches Arduino, permet plusieurs dispositifs I2C sur le même bus, simplifie le câblage avec seulement 4 connexions, et rend l'écran parfait pour les projets avec un nombre limité de broches disponibles. Le petit compromis est un taux de rafraîchissement légèrement plus lent par rapport au mode parallèle, mais ceci est imperceptible pour la plupart des applications.
Brochage
Le module LCD I2C dispose d'une interface simple à 4 broches qui utilise le protocole de communication I2C. Comprendre ces connexions est essentiel pour un fonctionnement correct :
- Broche GND : La broche de référence de masse. Connectez-la au GND (0V) de l'Arduino Mega pour compléter le circuit d'alimentation et établir une masse commune.
- Broche VCC : La broche d'alimentation. Connectez-la à la sortie 5V de l'Arduino Mega pour fournir la tension de fonctionnement à la fois pour l'écran LCD et la puce d'adaptateur I2C.
- Broche SDA : La ligne de données série pour la communication I2C. Cette broche bidirectionnelle transporte les données entre l'Arduino Mega et le module LCD. Connectez à la broche SDA de l'Arduino Mega (broche numérique 20).
- Broche SCL : La ligne d'horloge série pour la communication I2C. Cette broche transporte le signal d'horloge qui synchronise la transmission des données. Connectez à la broche SCL de l'Arduino Mega (broche numérique 21).
Note sur le bus I2C : Le bus I2C supporte plusieurs dispositifs sur les mêmes deux fils (SDA/SCL). Chaque dispositif a une adresse I2C unique (typiquement 0x27 ou 0x3F pour les modules LCD). Cela signifie que vous pouvez connecter plusieurs dispositifs I2C—tels que des capteurs, des RTC et des écrans—partageant tous les mêmes lignes SDA et SCL. Les broches I2C dédiées de l'Arduino Mega (20 et 21) sont optimisées pour une communication fiable.
Ajustement du contraste : À l'arrière de la carte adaptateur I2C, vous trouverez un petit potentiomètre bleu. Utilisez un petit tournevis pour tourner ce potentiomètre dans le sens horaire ou antihoraire pour ajuster le contraste du LCD pour une lisibilité optimale. Si vous ne pouvez voir aucun texte sur votre LCD, essayez d'ajuster ceci en premier !
Système de coordonnées LCD
Comprendre le système de coordonnées du LCD est crucial pour un placement précis du texte. Le LCD I2C 16x2 utilise un système de coordonnées de grille indexé à zéro où les colonnes et les lignes commencent à compter à partir de 0 (pas 1).
Structure des coordonnées :
- Colonnes : Vont de 0 à 15 (16 positions au total horizontalement)
- Lignes : Vont de 0 à 1 (2 lignes au total verticalement)
- Format : lcd.setCursor(colonne, ligne) où la colonne vient en premier
Exemples :
- Coin supérieur gauche : (0, 0) - Première colonne, première ligne
- Coin supérieur droit : (15, 0) - Dernière colonne, première ligne
- Coin inférieur gauche : (0, 1) - Première colonne, deuxième ligne
- Coin inférieur droit : (15, 1) - Dernière colonne, deuxième ligne
- Centre de la ligne supérieure : (7, 0) ou (8, 0) - Colonnes du milieu, première ligne
Conseils pratiques :
- Le texte se wrappe automatiquement : si vous imprimez plus de 16 caractères en commençant à (0,0), il continue sur la ligne 1
- La position du curseur persiste : une fois définie, les appels lcd.print() suivants continuent à partir de cette position
- Centrer le texte : pour une chaîne de 10 caractères sur un écran de 16 colonnes, commencez à la colonne (16-10)/2 = 3
Schéma de câblage
Maintenant, examinons le câblage simple et élégant entre votre Arduino Mega et le module LCD I2C. Grâce à l'interface I2C, nous n'avons besoin que de 4 fils !
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Résumé des connexions pour Arduino Mega :
| LCD I2C | Arduino Uno, Nano | Arduino Mega |
|---|---|---|
| Vin | 5V | 5V |
| GND | GND | GND |
| SDA | A4 | 20 |
| SCL | A5 | 21 |
Important : L'Arduino Mega utilise des broches I2C différentes des cartes Arduino plus petites ! Alors que l'Arduino Uno et Nano utilisent les broches A4 (SDA) et A5 (SCL), l'Arduino Mega utilise les broches 20 (SDA) et 21 (SCL). Vérifiez toujours que vous vous connectez aux bonnes broches pour votre carte spécifique.
Bonnes pratiques de câblage :
- Utilisez des fils de connexion courts (moins de 30cm) pour une communication I2C fiable
- Gardez les fils SDA et SCL éloignés des lignes d'alimentation bruyantes
- Si vous utilisez de longs fils (>1 mètre), envisagez d'ajouter des résistances de pull-up (4,7kΩ) sur les lignes SDA et SCL
- Le module I2C inclut généralement des pull-ups intégrés, mais des résistances externes peuvent améliorer la fiabilité dans des environnements bruyants
Comment programmer pour LCD I2C
Explorons les techniques de programmation essentielles pour contrôler votre écran LCD I2C. La bibliothèque LiquidCrystal_I2C simplifie les opérations LCD, gérant toute la communication I2C complexe en arrière-plan.
Inclure la bibliothèque
D'abord, incluez la bibliothèque LiquidCrystal_I2C en haut de votre sketch :
Cette bibliothèque fournit toutes les fonctions nécessaires pour communiquer avec les écrans LCD basés sur I2C.
Créer l'objet LCD
Créez un objet LiquidCrystal_I2C en spécifiant trois paramètres : l'adresse I2C, le nombre de colonnes et le nombre de lignes :
Adresse I2C : La plupart des modules LCD I2C utilisent l'adresse 0x27 ou 0x3F. Si votre LCD ne fonctionne pas avec 0x27, essayez 0x3F. Vous pouvez aussi scanner les dispositifs I2C en utilisant un sketch de scanner I2C pour trouver l'adresse correcte.
Initialiser le LCD
Dans votre fonction setup(), initialisez le LCD et activez le rétroéclairage :
La fonction init() prépare le LCD pour le fonctionnement, tandis que backlight() illumine l'écran. Vous pouvez utiliser lcd.noBacklight() pour l'éteindre plus tard si nécessaire.
Positionner le curseur
Avant d'afficher du texte, définissez la position du curseur en utilisant les coordonnées de colonne et de ligne :
Rappelez-vous : les colonnes vont de 0-15, les lignes vont de 0-1. Le curseur détermine où le prochain caractère sera imprimé.
Afficher du texte
Utilisez la fonction print() pour afficher du texte ou des nombres sur le LCD :
La fonction print() fonctionne comme Serial.print(), acceptant des chaînes, des entiers, des nombres à virgule flottante et d'autres types de données.
Capacités supplémentaires
La bibliothèque fournit beaucoup plus de fonctions pour le contrôle avancé du LCD. Voir la section "Faire plus avec LCD" ci-dessous pour les caractères personnalisés, le texte défilant, le contrôle du curseur, et plus !
※ Note:
Note sur l'adresse I2C : L'adresse I2C des modules LCD varie selon le fabricant. Notre code utilise 0x27, qui est standard pour les modules LCD DIYables. Si vous avez une marque différente, vous pourriez avoir besoin d'utiliser 0x3F ou exécuter un scanner I2C pour détecter l'adresse.
Code Arduino Mega
Étapes rapides
Suivez ces instructions détaillées étape par étape pour faire fonctionner votre écran LCD I2C avec votre Arduino Mega :
1. Connexions physiques : Câblez l'écran LCD I2C à l'Arduino Mega en suivant le schéma de câblage montré ci-dessus. Vérifiez bien les quatre connexions : VCC vers 5V, GND vers GND, SDA vers la broche 20, et SCL vers la broche 21.
2. Connexion USB : Connectez la carte Arduino Mega à votre ordinateur en utilisant un câble USB. Attendez que votre système d'exploitation reconnaisse la carte et installe les pilotes nécessaires.
3. Ouvrir l'IDE Arduino : Lancez le logiciel Arduino IDE sur votre ordinateur. Si vous ne l'avez pas encore installé, téléchargez-le depuis le site officiel Arduino.
4. Sélection de la carte : Dans l'IDE Arduino, naviguez vers Outils → Carte et sélectionnez "Arduino Mega or Mega 2560" dans la liste des cartes disponibles.
5. Sélection du port : Allez à Outils → Port et choisissez le port COM (Windows) ou le port /dev/ttyUSB ou /dev/ttyACM (Mac/Linux) qui correspond à votre Arduino Mega connecté.
6. Installation de la bibliothèque : Cliquez sur l'icône Bibliothèques (icône de livre) dans la barre latérale gauche de l'IDE Arduino. Dans la boîte de recherche, tapez "LiquidCrystal I2C" et localisez la bibliothèque LiquidCrystal_I2C par Frank de Brabander.
7. Installer la bibliothèque : Cliquez sur le bouton Installer pour ajouter la bibliothèque LiquidCrystal_I2C à votre IDE Arduino. Attendez que l'installation soit terminée.
8. Téléverser le code : Copiez le code d'exemple fourni ci-dessus et collez-le dans un nouveau sketch de l'IDE Arduino. Cliquez sur le bouton Téléverser (icône flèche droite) dans la barre d'outils pour compiler et téléverser le code vers votre Arduino Mega.
9. Vérifier la sortie : Regardez l'écran LCD. Vous devriez voir "DIYables" affiché sur la première ligne à la position de colonne 3, et "www.diyables.io" affiché sur toute la deuxième ligne.
10. Ajuster le contraste (si nécessaire) : Si vous ne pouvez pas voir le texte clairement ou pas du tout, utilisez un petit tournevis pour tourner soigneusement le potentiomètre bleu à l'arrière de la carte adaptateur I2C jusqu'à ce que le texte devienne clairement visible.
Expérimentez davantage : Essayez de modifier les chaînes de texte et les positions du curseur dans le code pour afficher vos propres messages et mises en page personnalisés !
Vidéo
Faire plus avec LCD
Générateur de caractères personnalisés
Une des fonctionnalités les plus puissantes des écrans LCD est la capacité de créer et d'afficher des caractères personnalisés—des symboles spéciaux, des icônes et des graphiques qui vont au-delà du texte ASCII standard. Vous voulez afficher un symbole de cœur, un indicateur de batterie, un symbole de degré, ou même un petit angry bird ? Le générateur de caractères personnalisés le rend possible !
Comprendre les pixels LCD :
Chaque position de caractère sur le LCD 16x2 consiste en une grille de 40 petits pixels arrangés en 8 lignes par 5 colonnes. En allumant ou éteignant sélectivement ces pixels, vous pouvez créer n'importe quel symbole ou forme que vous pouvez imaginer dans cet espace 5×8.
Comment ça fonctionne :
Le contrôleur LCD (HD44780) peut stocker jusqu'à 8 caractères personnalisés dans sa CGRAM (Character Generator RAM), numérotés de 0 à 7. Vous définissez le motif de pixels pour chaque caractère en utilisant un tableau d'octets où chaque octet représente une ligne, et les 5 bits inférieurs contrôlent quels pixels sont allumés.
Utiliser l'outil générateur de caractères :
L'éditeur de pixels interactif ci-dessous vous permet de concevoir visuellement des caractères personnalisés. Suivez simplement ces étapes :
Résultat affiché sur l'écran :
Plusieurs caractères personnalisés
Le contrôleur LCD HD44780 fournit huit emplacements CGRAM (adresses 0-7) pour stocker des caractères personnalisés. Cela signifie que vous pouvez définir jusqu'à huit symboles personnalisés différents dans un seul projet ! C'est parfait pour créer des éléments d'interface utilisateur comme des indicateurs de batterie (vide, moitié, plein), des flèches directionnelles, des symboles de degré, des notes de musique, ou tout ensemble d'icônes dont votre projet a besoin.
Exemple : Trois caractères personnalisés
L'exemple ci-dessous montre comment créer et afficher trois caractères personnalisés différents : un cœur, une flèche vers le haut et une flèche vers le bas. Remarquez comment chaque caractère est stocké dans son propre tableau d'octets et enregistré avec un index unique (0, 1, 2).
Résultat affiché sur l'écran LCD :
Résumé : Création et utilisation de caractères personnalisés sur LCD
Suivez ce flux de travail complet pour concevoir et afficher vos propres caractères personnalisés :
Étape 1 : Concevez votre caractère
Utilisez l'outil d'éditeur de pixels interactif ci-dessus pour concevoir visuellement votre caractère personnalisé. Cliquez sur des pixels individuels pour les allumer (noir) ou les éteindre (blanc) jusqu'à ce que vous ayez créé la forme ou le symbole souhaité.
Étape 2 : Copiez le code généré
L'outil génère automatiquement le code du tableau d'octets pour votre caractère. Copiez ce code binaire depuis la sortie du générateur :
Étape 3 : Enregistrez le caractère
Dans votre fonction setup(), enregistrez le caractère personnalisé dans l'un des 8 emplacements CGRAM disponibles (index 0-7) en utilisant la fonction createChar() :
Étape 4 : Affichez le caractère
N'importe où dans votre code (setup() ou loop()), positionnez le curseur et affichez le caractère personnalisé en utilisant son index :
Notes importantes :
- Les caractères personnalisés persistent dans la CGRAM jusqu'à ce que vous éteigniez le LCD ou que vous les écrasiez
- Vous pouvez réutiliser le même caractère personnalisé plusieurs fois à différentes positions sur l'écran
- Chaque caractère occupe l'une des 32 positions d'affichage (comme les caractères ASCII ordinaires)
- Les 8 emplacements de caractères personnalisés sont indépendants—vous pouvez mélanger des caractères personnalisés et réguliers librement
Fonctions de contrôle LCD supplémentaires
La bibliothèque LiquidCrystal_I2C fournit de nombreuses fonctions puissantes au-delà de l'affichage de texte de base. Ces fonctions vous donnent un contrôle complet sur l'apparence et le comportement du LCD.
Effacer l'affichage :
Supprime tout le texte du LCD et ramène le curseur à la position (0,0). Utilisez ceci lorsque vous souhaitez actualiser complètement l'affichage avec un nouveau contenu.
Retourner le curseur à la position initiale :
Déplace le curseur vers la position du coin supérieur gauche (0,0) sans effacer l'affichage. C'est plus rapide que clear() lorsque vous souhaitez garder le contenu existant visible.
Définir la position du curseur :
Déplace le curseur vers une colonne et une ligne spécifiques. Essentiel pour positionner le texte précisément sur l'affichage.
Afficher le curseur souligné :
Affiche un curseur souligné à la position actuelle. Utile pour indiquer où le prochain caractère apparaîtra, notamment dans les applications de saisie utilisateur.
Masquer le curseur :
Désactive l'affichage du curseur. Cela crée une apparence plus propre lorsqu'il n'y a pas de saisie utilisateur.
Activer le curseur clignotant :
Affiche un curseur de bloc clignotant à la position actuelle. Cela fournit un indicateur visuel plus prominent pour les champs de saisie utilisateur.
Désactiver le curseur clignotant :
Arrête le clignotement du curseur, le retournant à l'affichage stable (si cursor() est activé) ou caché (si noCursor() est défini).
Contrôle du rétroéclairage :
Vous pouvez allumer et éteindre dynamiquement le rétroéclairage pour économiser de l'énergie ou créer des effets attractifs :
Activation/Désactivation de l'affichage :
Contrôlez si le contenu est visible sans perdre les données dans la RAM d'affichage :
Conseil d'utilisation avancée : Essayez de tester ces fonctions séquentiellement dans votre loop() avec delay(5000) entre chacune pour observer leurs effets. Pour une documentation complète, visitez la référence officielle de la bibliothèque LiquidCrystal : https://arduinogetstarted.com/reference/library/arduino-lcd-library
Dépannage des problèmes d'affichage LCD I2C
Vous rencontrez des problèmes avec votre affichage LCD I2C ? Suivez ce guide de dépannage complet pour diagnostiquer et résoudre les problèmes courants.
Problème : Aucun texte visible sur le LCD
Solution 1 : Ajuster le contraste
Le problème le plus courant ! À l'arrière de la carte adaptateur I2C, vous trouverez un petit potentiomètre bleu (potentiomètre d'ajustement). Utilisez un petit tournevis plat pour tourner soigneusement ce potentiomètre dans le sens horaire ou antihoraire. Vous devriez voir le contraste du texte changer—de invisible à léger à clair à des blocs noirs. Ajustez jusqu'à ce que le texte soit clairement lisible.
Solution 2 : Vérifier l'adresse I2C
Différents modules LCD I2C utilisent différentes adresses I2C selon le fabricant. Les deux adresses les plus courantes sont 0x27 et 0x3F. Si votre LCD ne répond pas avec une adresse, essayez l'autre dans votre code :
Solution 3 : Scanner pour l'adresse I2C
Si ni 0x27 ni 0x3F ne fonctionnent, utilisez ce sketch de scanner I2C pour détecter automatiquement l'adresse correcte de votre module LCD :
Comment utiliser le scanner :
- Téléversez le code du scanner I2C sur votre Arduino Mega
- Ouvrez le Moniteur Série (Outils → Moniteur Série) et réglez le débit en bauds à 9600
- Observez les résultats de scan toutes les 5 secondes
- Notez l'adresse hexadécimale affichée (par ex. 0x27 ou 0x3F)
- Utilisez cette adresse dans le constructeur LiquidCrystal_I2C lcd()
Exemple de sortie du Moniteur Série :
Dans cet exemple, le LCD est détecté à l'adresse 0x3F, donc vous utiliseriez :
Conseils de dépannage supplémentaires
Vérifier les connexions de câblage :
- Vérifiez que VCC se connecte au 5V de l'Arduino (pas au 3,3V)
- Confirmez que GND se connecte au GND de l'Arduino
- Vérifiez à nouveau que SDA va à la broche 20 sur l'Arduino Mega (pas A4)
- Assurez-vous que SCL va à la broche 21 sur l'Arduino Mega (pas A5)
- Inspectez les connexions lâches ou cassées
Problèmes d'alimentation :
- Le LCD consomme 20-40mA de courant avec le rétroéclairage allumé
- Si vous utilisez l'alimentation USB, assurez-vous que votre ordinateur fournit un courant suffisant
- Essayez une alimentation 5V externe si l'alimentation USB semble insuffisante
- Mesurez la tension à la broche VCC du LCD (devrait être proche de 5,0V)
Problèmes de bibliothèque :
- Confirmez que vous avez installé la bonne bibliothèque : LiquidCrystal_I2C by Frank de Brabander
- Redémarrez l'IDE Arduino après l'installation de nouvelles bibliothèques
- Vérifiez les bibliothèques en conflit avec des noms similaires
Problèmes matériels :
- Inspectez les joints de soudure sur l'adaptateur I2C pour les soudures froides ou les ponts
- Testez avec un autre module LCD si disponible
- Vérifiez que l'adaptateur I2C est correctement connecté au LCD (certains modules ont des adaptateurs amovibles)
En travaillant systématiquement à travers ces étapes de dépannage, vous devriez être en mesure de résoudre la plupart des problèmes d'affichage LCD I2C !