Ceci est notre sixième didacticiel de notre série de didacticiels PIC.Dans ce didacticiel, nous apprenons l' interfaçage d'un écran LCD 16x2 avec un microcontrôleur PIC. Dans nos tutoriels précédents, nous avons appris les bases de PIC à l'aide de certains programmes de clignotement de LED et avons également appris comment utiliser les minuteries dans le microcontrôleur PIC. Vous pouvez consulter ici tous les tutoriels sur l'apprentissage des microcontrôleurs PIC utilisant le compilateur MPLABX et XC8.
Ce tutoriel sera intéressant car nous allons apprendre comment interfacer un écran LCD 16 × 2 avec PIC16F877A, consultez la vidéo détaillée à la fin de ce tutoriel. Il est révolu le bon vieux temps où nous utilisions des LED pour les indications des utilisateurs. Voyons comment nous pouvons rendre nos projets plus cool et plus utiles en utilisant des écrans LCD. Consultez également nos articles précédents sur Interfaçage LCD avec 8051, avec Arduino, avec Raspberry Pi, avec AVR.
Fonctions d'interfaçage de l'écran LCD avec le microcontrôleur PIC:
Pour faciliter les choses, nous avons créé une petite bibliothèque qui pourrait faciliter les choses en utilisant cet écran LCD avec notre PIC16F877A. Le fichier d'en-tête "MyLCD.h" est donné ici pour téléchargement, qui contient toutes les fonctions nécessaires pour piloter l'écran LCD en utilisant PIC MCU. Le code de la bibliothèque est bien expliqué par des lignes de commentaires, mais si vous avez encore des doutes, contactez-nous via la section des commentaires. Consultez également cet article pour le fonctionnement de l'écran LCD de base et ses brochages.
Remarque: il est toujours recommandé de savoir ce qui se passe réellement dans votre fichier d'en-tête car cela vous aidera dans le débogage ou lors du changement de MCU.
Maintenant, il existe deux façons d'ajouter ce code dans votre programme. Vous pouvez soit copier toutes les lignes de code ci-dessus dans MyLCD.h et les coller avant le void main (). Ou vous pouvez télécharger le fichier d'en-tête en utilisant le lien et les ajouter au fichier d'en-tête de votre projet ( #include "MyLCD.h "; ). Cela peut être fait en cliquant avec le bouton droit sur le fichier d'en-tête et en sélectionnant Ajouter un élément existant et en parcourant ce fichier d'en-tête.
Ici, j'ai copié et collé le code du fichier d'en-tête dans mon fichier C principal. Donc, si vous utilisez notre code, vous n'avez pas besoin de télécharger et d'ajouter le fichier d'en-tête dans votre programme, utilisez simplement le code complet donné à la fin de ce tutoriel. Notez également que cette bibliothèque ne prend en charge que le microcontrôleur PIC de la série PIC16F.
Ici, j'explique chaque fonction dans notre fichier d'en-tête ci-dessous:
void Lcd_Start (): Cette fonction devrait être la première fonction qui doit être appelée pour commencer à travailler avec notre écran LCD. Nous ne devons appeler cette fonction qu'une seule fois pour éviter les retards dans le programme.
void Lcd_Start () {Lcd_SetBit (0x00); pour (int i = 1065244; i <= 0; i--) NOP (); Lcd_Cmd (0x03); __delay_ms (5); Lcd_Cmd (0x03); __delay_ms (11); Lcd_Cmd (0x03); Lcd_Cmd (0x02); // 02H est utilisé pour Return home -> Efface la RAM et initialise le LCD Lcd_Cmd (0x02); // 02H est utilisé pour Return home -> Efface la RAM et initialise le LCD Lcd_Cmd (0x08); // Sélectionnez la ligne 1 Lcd_Cmd (0x00); // Effacer l'affichage de la ligne 1 Lcd_Cmd (0x0C); // Sélectionnez la ligne 2 Lcd_Cmd (0x00); // Effacer l'affichage de la ligne 2 Lcd_Cmd (0x06); }
Lcd_Clear (): Cette fonction efface l'écran LCD et peut être utilisée à l'intérieur des boucles pour effacer l'apparence des données précédentes.
Lcd_Clear () {Lcd_Cmd (0); // Efface l'écran LCD Lcd_Cmd (1); // Déplace le curseur en première position}
void Lcd_Set_Cursor (x pos, y pos): Une fois démarré, notre écran LCD est prêt à prendre des commandes, nous pouvons demander à l'écran LCD de placer son curseur à votre emplacement préféré en utilisant cette fonction. Supposons que nous ayons besoin du curseur au 5e caractère de la 1ère ligne. Ensuite, la fonction sera vide Lcd_Set_Cursor (1, 5)
void Lcd_Set_Cursor (char a, char b) {char temp, z, y; si (a == 1) {temp = 0x80 + b - 1; // 80H est utilisé pour déplacer le curseur z = temp >> 4; // 8 bits inférieurs y = temp & 0x0F; // Lcd_Cmd (z) 8 bits supérieurs; // Définir la ligne Lcd_Cmd (y); // Définir la colonne} else if (a == 2) {temp = 0xC0 + b - 1; z = température >> 4; // 8 bits inférieurs y = temp & 0x0F; // Lcd_Cmd (z) 8 bits supérieurs; // Définir la ligne Lcd_Cmd (y); // Définir la colonne}}
void Lcd_Print_Char (char data): Une fois que le curseur est positionné, nous pouvons écrire un caractère à sa position en appelant simplement cette fonction.
void Lcd_Print_Char (char data) // Envoie 8 bits en mode 4 bits {char Lower_Nibble, Upper_Nibble; Lower_Nibble = données & 0x0F; Upper_Nibble = données & 0xF0; RS = 1; // => RS = 1 Lcd_SetBit (Upper_Nibble >> 4); // Envoie la moitié supérieure en décalant de 4 EN = 1; pour (int i = 2130483; i <= 0; i--) NOP (); EN = 0; Lcd_SetBit (Lower_Nibble); // Envoyer la moitié inférieure EN = 1; pour (int i = 2130483; i <= 0; i--) NOP (); EN = 0; }
void Lcd_Print_String (char * a): Si un groupe de caractères doit être affiché, la fonction de chaîne peut être utilisée.
void Lcd_Print_String (char * a) {int i; pour (i = 0; a! = '\ 0'; i ++) Lcd_Print_Char (a); // Divise la chaîne à l'aide de pointeurs et appelle la fonction Char}
Chaque fois que le Lcd_Print_Char (données char) est appelé, ses valeurs de caractères respectives sont envoyées aux lignes de données de l'écran LCD. Ces caractères atteignent le HD44780U sous forme de bits. Maintenant, cet IC relie les bits au caractère à afficher en utilisant sa mémoire ROM comme indiqué dans le tableau ci-dessous. Vous pouvez trouver des bits pour tous les caractères dans la fiche technique du contrôleur LCD HD44780U.
Maintenant, puisque nous sommes satisfaits de notre fichier d'en-tête, construisons le circuit et testons le programme. Vérifiez également le fichier d'en-tête complet fourni dans le lien ci-dessus.
Schéma de circuit et test:
Vous trouverez ci-dessous le schéma de circuit pour l'interfaçage de l'écran LCD 16x2 avec le microcontrôleur PIC.
Je n'ai pas montré l'alimentation ou la connexion ICSP dans le circuit ci-dessus, car nous utilisons la même carte que celle que nous avons utilisée dans le tutoriel précédent, vérifiez ici.
Une chose importante à noter dans le programme est la définition des broches de l'écran LCD:
#define RS RD2 #define EN RD3 #define D4 RD4 #define D5 RD5 #define D6 RD6 #define D7 RD7
Ces définitions de broches peuvent être modifiées en fonction de la configuration matérielle du programmeur. N'oubliez pas de changer la configuration de port respectée dans la fonction principale si vous changez ici.
Le matériel pour ce projet est très simple. Nous allons réutiliser le même module PIC que nous avons utilisé la dernière fois et connecter le module LCD à notre PIC à l'aide de câbles de raccordement.
La connexion peut être comprise par le tableau suivant:
|
Broche LCD No. |
Nom de la broche LCD |
Nom de la broche MCU |
Broche MCU No. |
|
1 |
Sol |
Sol |
12 |
|
2 |
VCC |
+ 5V |
11 |
|
3 |
VEE |
Sol |
12 |
|
4 |
S'inscrire Sélectionnez |
RD2 |
21 |
|
5 |
Lire écrire |
Sol |
12 |
|
6 |
Activer |
RD3 |
22 |
|
sept |
Bit de données 0 |
NC |
- |
|
8 |
Bit de données 1 |
NC |
- |
|
9 |
Bit de données 2 |
NC |
- |
|
dix |
Bit de données 3 |
NC |
- |
|
11 |
Bit de données 4 |
RD4 |
27 |
|
12 |
Bit de données 5 |
RD5 |
28 |
|
13 |
Bit de données 6 |
RD6 |
29 |
|
14 |
Bit de données 7 |
RD7 |
30 |
|
15 |
LED positive |
+ 5V |
11 |
|
16 |
LED négative |
Sol |
12 |
Maintenant, faisons simplement les connexions, vidons le code sur notre MCU et vérifions la sortie.
Si vous avez des problèmes ou des doutes, veuillez utiliser la section des commentaires. Consultez également la vidéo de démonstration ci-dessous.