Comment interface LCD avec Esptop 10 en utilisant Arduino IDE

ESP32 est un microcontrôleur basé sur l'IoT qui peut traiter plusieurs instructions comme Arduino, mais il vient par défaut avec Bluetooth et WiFi. ESP32 est une carte autonome qui peut aider d'autres systèmes à réduire leur charge car il peut agir comme un appareil maître ou esclave. Comme Arduino, nous pouvons également interfacer un écran LCD avec ESP32. Discutons de la façon de le faire en détail.

Interfaçage LCD avec ESP32 en utilisant Arduino IDE

L'écran LCD I2C peut afficher les processus de données lors de la programmation sur un écran. Il donne une représentation visuelle des données reçues de capteurs, de modules ou de microcontrôleurs. L'écran LCD peut être intégré sans utiliser le module I2C mais l'avantage de l'utilisation de I2C est qu'il n'utilise que deux fils SDA et SCL Pour communiquer des données qui se traduisent avec plusieurs E / OS gratuites sur ESP32 qui peuvent être utilisées pour intégrer d'autres appareils.

De plus, il a un potentiomètre à bord qui peut contrôler la luminosité de l'écran LCD en ajustant simplement le bouton du potentiomètre.

Câblage de l'écran LCD à l'ESP32 avec I2C

Connectez le module I2C avec ESP32 à l'aide de broches numériques 21 et 22 de l'ESP32. L'image ci-dessous représente les connexions de I2C avec un écran ESP32 et LCD. La broche SDA de I2C est connectée à la broche GPIO 21 de ESP32 et la broche SCL de I2C de la même manière est jointe à la broche GPIO 22.

Le tableau ci-dessous représente la connexion d'ESP32 avec I2C.

LCD I2C	ESP32
GND	GND
VCC	Vin
SDA	GPIO 21
SCL	GPIO 22

Installation de la bibliothèque LiquidCrystal_I2C dans Arduino IDE

Une fois le circuit terminé, connectez la carte ESP32 avec PC. Ouvre maintenant l'IDE et allez à Responsable de bibliothèque Rechercher Crystal liquide I2C bibliothèque. Installez la bibliothèque donnée par Frank de Brabander.

Une fois que vous cliquez sur l'installation des fichiers de bibliothèque commencera à télécharger, lors de l'installation réussie, vous recevrez un message installé de la bibliothèque dans la fenêtre de sortie.

Obtenir l'adresse LCD

Avant de connecter tout appareil I2C à ESP32, il est important de noter à quelle adresse cet appareil spécifique est connecté. Certains modules ont des adresses I2C par défaut écrites alors que certaines d'entre elles n'ont aucune instruction pour vérifier les adresses I2C.

Pour résoudre ce problème, nous avons un fil Code de bibliothèque qui vérifie tous les périphériques I2C connectés et à quelle adresse ils sont connectés à ESP32. Cela aidera à déboguer et à améliorer le circuit ESP32.

#include / * Inclure du fil.H Library H * /
void setup()

Fil.commencer(); / * Wire I2C Communication Start * /
En série.commencer (115200); / * Ensemble de taux de bauds pour la communication série * /
alors que (!En série); / * En attente de sortie série sur moniteur série * /
En série.println ("\ ni2c scanner");

VOID LOOP ()

octet err, ADR; / * L'erreur de variable est définie avec l'adresse de i2c * /
int number_of_devices;
En série.println ("Scanning.");
Number_Of_Devices = 0;
pour (ADR = 1; ADR < 127; adr++ )

Fil.BeginTransmission (ADR);
err = fil.endtransmission ();
if (err == 0)

En série.print ("périphérique I2C à l'adresse 0x");
si (ADR < 16)
En série.print ("0");
En série.imprimer (ADR, hex);
En série.println (" !");
numéro_of_devices ++;

else if (err == 4)

En série.print ("Erreur inconnue à l'adresse 0x");
si (ADR < 16)
En série.print ("0");
En série.println (adr, hex);


if (number_of_devices == 0)
En série.println ("no I2C Device attaché \ n");
autre
En série.println ("Done \ n");
retard (5000); / * attendez 5 secondes pour le prochain scan I2C * /

Ce code aidera à trouver le numéro de périphériques I2C et leur adresse à laquelle ils sont connectés. Ce code est communément appelé code de scanner I2C.

Tout d'abord, nous avons inclus un "Fil.h ” bibliothèque. Ensuite, dans la partie de configuration du code, nous avons commencé cette bibliothèque. Après cela, nous initialisons la communication série en définissant le taux de bauds 9600. Cela aidera à voir la sortie sur le moniteur en série.

Dans la section Loop, nous avons défini deux variables "se tromper" et «ADR». Ensuite, nous avons défini une autre variable "Dispositifs" et le régler sur zéro. Après ça un pour la boucle est initialisée avec des valeurs comprises entre 0 et 127.

Ensuite, nous entrons l'adresse au fil en utilisant fil.BeginTransmission (), Le scanner I2C recherchera la reconnaissance des appareils et leur adresse. La valeur lecture sera stockée dans la variable "erreur". La valeur de retour sera égale à 0 si le périphérique reconnaît que l'adresse autrement deviendra 4. Ensuite, nous avons utilisé une condition IF qui imprimera l'adresse du périphérique I2C si la valeur est <16. Final address of the device is printed in Hexadecimal form.

La sortie des dispositifs attachés à ESP32 sur les protocoles I2C ressemblera à ce que le diagramme ci-dessous. Ici 0x3c est l'adresse de l'écran LCD I2C alors que 0x27 est l'adresse de l'OLED filtrer.

Affichage du texte sur l'écran LCD

L'affichage du texte sur un LCD à l'aide d'ESP32 est très simple. Tout ce dont nous avons besoin est de sélectionner la ligne et la colonne de l'écran LCD où nous voulons afficher les caractères. Vous trouverez ci-dessous un programme très simple affichage "Linuxhint ESP32".

#inclure
/ * Initialiser les colonnes et les lignes LCD * /
int lcd_columns = 16;
int lcd_rows = 2;
/ * Définir l'adresse LCD, le nombre de colonnes et de lignes * /
/ * Pour connaître l'adresse I2C (0x27), exécutez un croquis du scanner I2C * /
LiquidCrystal_I2C LCD (0x27, LCD_Columns, LCD_ROWS);
void setup()
/ * Initialiser LCD * /
LCD.init ();
/ * activer le rétroéclairage LCD * /
LCD.Backlight ();

VOID LOOP ()
/ * Réglez le curseur sur la première colonne, première ligne * /
LCD.setCursor (0, 0);
/ * Imprimer le message * /
LCD.print ("LinuxHint ESP32");
retard (1000);
/ * efface l'affichage pour imprimer un nouveau message * /
LCD.clair();

Lors de l'écriture de code, la première chose dont nous avons besoin est d'appeler la bibliothèque de cristal liquides que nous avons installée.

#inclure

Les deux lignes suivantes représentent les lignes et les colonnes de l'écran LCD où nous avons besoin de texte pour afficher. Si vous utilisez un affichage de toute autre taille, modifiez la ligne et la colonne en conséquence.

int lcd_columns = 16;
int lcd_rows = 2;

Ensuite, nous afficherons l'adresse I2C à laquelle le module I2C LCD est connecté. Dans notre cas, c'est 0x27. Si vous utilisez une version similaire de l'écran LCD, cela peut être le même que le nôtre, autrement, le code de vérification de l'adresse indiqué ci-dessus.

LiquidCrystal_I2C LCD (0x27, LCD_Columns, LCD_ROWS);

Ensuite, nous avons initialisé l'affichage et le rétro-éclairage de l'écran LCD en utilisant les commandes suivantes.

LCD.init ();
LCD.Backlight ();

Pour afficher le texte, la commande du curseur LCD est utilisée 0 correspond à la première colonne et à la ligne.

LCD.setCursor (0, 0);

Après cela, le LCD.La fonction print () est utilisée pour afficher le texte, puis nous effacons l'écran en utilisant LCD.clair().

LCD.print ("LinuxHint ESP32");
LCD.clair();

Sortir

La sortie du code représente les caractères définis dans le programme sur l'écran LCD.

Conclusion

Nous avons couvert toutes les étapes pour connecter un écran LCD avec ESP32 en utilisant le module I2C. Pour connecter l'écran LCD, nous devons d'abord installer la bibliothèque en utilisant le gestionnaire de bibliothèque. Ensuite, en utilisant l'adresse I2C correcte, nous pouvons envoyer toutes les données que nous souhaitons à l'écran LCD.