- Matériaux nécessaires
- Module d'affichage LCD 16X2
- Schéma de circuit et connexions
- Programmation ARM7-LPC2148
L'affichage est la partie nécessaire d'une machine, qu'il s'agisse d'appareils électroménagers ou de machines industrielles. L'écran affiche non seulement les options de contrôle pour faire fonctionner la machine, mais également l'état et la sortie de la tâche effectuée par cette machine. Il existe de nombreux types d'écrans utilisés dans l'électronique comme l'affichage à 7 segments, l'écran LCD, l'écran tactile TFT, l'écran LED, etc. L'écran LCD 16x2 est le plus basique et également utilisé dans certains petits équipements électroniques, nous avons fait beaucoup de projets utilisant un écran LCD 16x2 comprenant l'interfaçage de base avec d'autres microcontrôleurs:
- Interfaçage LCD avec le microcontrôleur 8051
- Interface LCD avec le microcontrôleur ATmega32
- Interfaçage LCD avec microcontrôleur PIC
- Interfaçage LCD 16x2 avec Arduino
- Interfaçage LCD 16x2 avec Raspberry Pi en utilisant Python
Dans ce tutoriel, nous verrons comment interfacer un LCD 16x2 avec le microcontrôleur ARM7-LPC2148 et afficher un simple message de bienvenue. Si vous êtes nouveau avec ARM7, commencez par les bases de ARM7 LPC2148 et apprenez comment il peut être programmé à l'aide de Keil uVision
Matériaux nécessaires
Matériel
- Carte microcontrôleur ARM7-LPC2148
- LCD (16X2)
- Potentiomètre
- IC régulateur de tension 5V
- Planche à pain
- Connexion des fils
- Pile 9V
- Câble micro USB
Logiciel
- Keil uVision 5
- Outil Magic Flash
Avant d'entrer dans le projet, nous devons connaître peu de choses sur les modes de fonctionnement de l'écran LCD et sur les codes hexadécimaux LCD.
Module d'affichage LCD 16X2
Un écran LCD 16X2 indique qu'il a 16 colonnes et 2 lignes. Cet écran LCD a 16 broches. L'image ci-dessous et le tableau montrent les noms des broches de l'écran LCD et ses fonctions.
|
NOM |
FONCTION |
|
VSS |
Broche de masse |
|
VDD |
Broche d'entrée + 5V |
|
VEE |
Broche de réglage du contraste |
|
RS |
S'inscrire Sélectionnez |
|
R / W |
Lire / écrire la broche |
|
E |
Activer la broche |
|
D0-D7 |
Broches de données (8 broches) |
|
LED A |
Broche d'anode (+ 5V) |
|
LED K |
Broche de cathode (GND) |
L'écran LCD peut fonctionner dans deux modes différents, à savoir le mode 4 bits et le mode 8 bits. En mode 4 bits, nous envoyons les données grignotage par quartet, d'abord le quartet supérieur, puis le quartet inférieur. Pour ceux d'entre vous qui ne savent pas ce qu'est un quartet: un quartet est un groupe de quatre bits, donc les quatre bits inférieurs (D0-D3) d'un octet forment le quartet inférieur tandis que les quatre bits supérieurs (D4-D7) d'un octet forment le quartet supérieur. Cela nous permet d'envoyer des données 8 bits.
Alors qu'en mode 8 bits, nous pouvons envoyer les données 8 bits directement en un seul passage puisque nous utilisons les 8 lignes de données.
Ici, dans ce projet, nous utiliserons le mode le plus couramment utilisé qui est le mode 4 bits. En mode quatre bits, nous pouvons enregistrer 4 broches de microcontrôleur et réduire également la surcharge de câblage.
16x2 utilise également le code HEX pour prendre n'importe quelle commande, il existe de nombreuses commandes hexadécimales pour LCD telles que déplacer le curseur, sélectionner le mode, déplacer le contrôle sur la deuxième ligne, etc. Pour en savoir plus sur le module d'affichage LCD 16X2 et les commandes hexadécimales, suivez le lien.
Schéma de circuit et connexions
Le tableau ci-dessous montre les connexions de circuit entre l'écran LCD et l'ARM7-LPC2148.
|
ARM7-LPC2148 |
Écran LCD (16x2) |
|
P0.4 |
RS (sélection de registre) |
|
P0.6 |
E (Activer) |
|
P0.12 |
D4 (broche de données 4) |
|
P0.13 |
D5 (broche de données 5) |
|
P0.14 |
D6 (broche de données 6) |
|
P0.15 |
D7 (broche de données 7) |
Connexions du régulateur de tension avec LCD et bâton ARM7
Le tableau ci-dessous montre les connexions entre ARM7 et LCD avec régulateur de tension.
|
Régulateur de tension IC |
Fonction Pin |
LCD et ARM-7 LPC2148 |
|
1. broche gauche |
+ Ve de la batterie 9V Entrée |
NC |
|
2. broche centrale |
- Ve de la batterie |
VSS, R / W, K de l'écran LCD GND de ARM7 |
|
3. broche droite |
Sortie régulée + 5V |
VDD, A de LCD + 5V d'ARM7 |
Potentiomètre avec LCD
Un potentiomètre est utilisé pour faire varier le contraste de l'écran LCD. Un pot a trois broches, la broche gauche (1) est connectée à + 5V et le centre (2) à VEE ou V0 du module LCD et la broche droite (3) est connectée à GND. On peut régler le contraste en tournant le bouton.
Paramètres des cavaliers
Une broche de cavalier est présente dans ARM7-Stick afin que nous puissions alimenter et télécharger le code en utilisant USB ou en utilisant une entrée 5V DC pour l'alimentation uniquement. Vous pouvez voir les images ci-dessous.
L'image ci-dessous montre que le cavalier est en position DC. Cela signifie que nous devons alimenter la carte à partir d'une alimentation externe 5V.
Et cette image montre que le cavalier est connecté en mode USB. Ici, l'alimentation et le code sont fournis via le port micro USB.
REMARQUE: Ici, dans ce didacticiel, nous avons téléchargé le code en utilisant USB en réglant le cavalier sur USB, puis nous avons changé le cavalier en mode CC pour alimenter le LPC2148 à partir de l'entrée 5v du régulateur. Vous pouvez le vérifier dans la vidéo donnée à la fin.
Le circuit final pour interfacer l'écran LCD 16x2 avec le microcontrôleur ARM7 ressemblera à ceci:
Programmation ARM7-LPC2148
Pour programmer ARM7-LPC2148, nous avons besoin de l'outil keil uVision & Flash Magic. Nous utilisons un câble USB pour programmer la clé ARM7 via le port micro USB. Nous écrivons du code en utilisant Keil et créons un fichier hexadécimal, puis le fichier HEX est flashé sur le bâton ARM7 à l'aide de Flash Magic. Pour en savoir plus sur l'installation de keil uVision et Flash Magic et comment les utiliser, suivez le lien Premiers pas avec le microcontrôleur ARM7 LPC2148 et programmez-le à l'aide de Keil uVision.
Le code complet d'interfaçage LCD avec ARM 7 est donné à la fin de ce tutoriel, nous en expliquons ici quelques parties.
Tout d'abord, nous devons inclure les fichiers d'en-tête requis
#comprendre
L'initialisation du module LCD est une étape très importante. Ici, nous utilisons certains codes HEX, qui sont en fait des commandes, pour indiquer à l'écran LCD le mode de fonctionnement (4 bits), le type d'écran LCD (16x2), la ligne de départ, etc.
void LCD_INITILIZE (void) // Fonction pour préparer l'écran LCD { IO0DIR = 0x0000FFF0; // Règle la broche P0.4, P0.6, P0.12, P0.13, P0.14, P0.15 comme OUTPUT delay_ms (20); LCD_SEND (0x02); // Initialise l'écran LCD en mode de fonctionnement 4 bits LCD_SEND (0x28); // 2 lignes (16X2) LCD_SEND (0x0C); // Affichage sur curseur désactivé LCD_SEND (0x06); // Curseur d'incrémentation automatique LCD_SEND (0x01); // Affichage clair LCD_SEND (0x80); // Première ligne première position }
Pour le mode 4 bits, nous avons différents types de fonction d'écriture pour les broches, c'est-à-dire en utilisant le quartet supérieur et inférieur. Voyons comment c'est fait
void LCD_SEND (char command) // Fonction pour envoyer des commandes hexadécimales grignotage par quartet { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((commande & 0xF0) << 8)); // Envoie le quartet supérieur de la commande IO0SET = 0x00000040; // Activation de HIGH IO0CLR = 0x00000030; // Rendre RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // Activer LOW delay_ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((commande & 0x0F) << 12)); // Envoi du quartet inférieur de la commande IO0SET = 0x00000040; // ACTIVER HIGH IO0CLR = 0x00000030; // RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // ACTIVER LOW delay_ms (5); }
Logique d'envoi de grignotage
IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((commande & 0x0F) << 12)); // Envoi du quartet inférieur de la commande IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((commande & 0xF0) << 8)); // Envoie le quartet supérieur de commande
Au-dessus de deux déclarations jouent un rôle important dans ce programme. La première commande envoie le quartet inférieur et la seconde envoie le quartet supérieur. C'est sans affecter les autres broches que nous faisons. Voyons comment cela se passe avant de connaître cette logique en premier
ORing- (A-0 = A), (A-1 = 1) ANDing- (A & 0 = 0), (A & 1 = A)
Nous utilisons donc un concept de masquage et une opération de décalage logique sans affecter les autres broches. Signifie que seules les broches (P0.12-P0.15) sont utilisées et qu'aucune autre broche telle que P0.4, P0.6 n'est affectée. Cela se fera en décalant les données de quatre bits et en faisant le quartet supérieur à la place du quartet inférieur et en masquant le quartet supérieur. Et puis nous rendons les bits inférieurs à zéro (0XF0) et ORed avec les données de quartet pour obtenir les données de quartet supérieur en sortie.
Un processus similaire est utilisé pour les données de moindre grignotage, mais ici, nous n'avons pas besoin de déplacer les données.
Lors de l'écriture de données sur la sortie, c'est-à-dire en mode de commande, RS doit être BAS et pour exécuter la validation doit être HAUT, et en mode données, RS doit être HAUT et pour exécuter la validation doit être HAUT.
Maintenant, pour envoyer la chaîne de données qui doit être imprimée en sortie, le même principe est utilisé grignotage par quartet. L'étape importante ici est que REGISTER SELECT (RS) doit être HIGH pour le mode données.
void LCD_DISPLAY (char * msg) // Fonction pour imprimer les caractères envoyés un par un { uint8_t i = 0; while (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Envoie le quartet supérieur IO0SET = 0x00000050; // RS HIGH & ENABLE HIGH pour imprimer les données IO0CLR = 0x00000020; // RW LOW Retard du mode d'écriture ms (2); IO0CLR = 0x00000040; // EN = 0, RS et RW inchangés (c'est-à-dire RS = 1, RW = 0) retard ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Envoie le quartet inférieur IO0SET = 0x00000050; // RS & EN HAUT IO0CLR = 0x00000020; retard ms (2); IO0CLR = 0x00000040; retard ms (5); i ++; }
Une vidéo complète de codage et de démonstration est donnée ci-dessous.