IDLabs-IoT Le site dédié aux objets connectés

Un site des laboratoires pédagogiques de l'école CampusID

Programmation d’un afficheur LCD sur Arduino

Posted on 11 novembre 2018  in Non classé

1 - Présentation générale de la technologie étudiée : 

 

a - qui a mis au point cette technologie ?

 

Il y a toujours des débats sur qui est l'inventeur des afficheurs à cristaux liquides mais  on sait que leurs premières utilisations concrètes remonte à 1985 ou Matsushita (aujourd'hui Panasonic) propose des écrans plat d’une taille et d'une résolution suffisante pour être utilisable sur des micro-ordinateurs, cependant on pourra voir l'apparition d'afficheurs LCD en couleur tout droit sorti des laboratoires de Thomson (Technicolor aujourd'hui) dès 1984.

Ce n'est qu'à partir de 1990 que les afficheurs LCD verrons leur utilisation proliférer dans une très large gamme d'électronique en tout genre et de toutes les formes, des téléphones portables en passant par les ordinateurs personnels jusqu'à la montre de poignet.

 

b - pour quelle raison cette technologie a été mise au point ? (quel était le besoin ?)

 

A l'aube des années 1900 l'électronique s'impose dans la vie de tout les jours et pour toutes les utilisations, l'air du tout digital est au coin de la rue et requière une façon plus compact pour afficher des digits, plusieurs technologies d'afficheurs compacts on vu le jour comme les afficheurs électroluminescent (afficheur LED), les afficheurs fluorescents, et bien sûr les afficheurs à cristaux liquides,

Mais là où les afficheurs électroluminescents étaient beaucoup trop coûteux en place, l'afficheur LCD s'est vu remporter la victoire face à l'afficheur LED dans son utilisation la plus rependue du fait de sa simplicité et l'absence de chaleur produite comparé au LED, mais surtout par son gain de place monumental ne prenant qu'à peine plus de place que affichage lui même.

 

c - description de la technologie

 

Description

Le Shield LCD KeyPad est un module développé pour pouvoir s’emboiter sur une carte Arduino et dispose même d’une bibliothèque avec certaines instructions de l’écran LCD sous forme de fonctions simplifiées pour la programmation. Il se compose d'un écran LCD 2x16 rétro éclairé bleu avec 1602 caractères blancs. Le clavier se compose de 5 touches : sélectionner, haut, droite, bas et gauche. Pour économiser les broches E / S numériques, l'interface du clavier utilise un seul canal CAN. La valeur de clé est lue à travers un diviseur de tension à 5 étages.

Fonctionnement

Le shield comprend un écran LCD  et 6 boutons poussoirs momentanés. Les broches 4, 5, 6, 7, 8, 9 et 10 sont utilisées pour l'interface avec l'écran LCD. La broche analogique 0 est utilisée pour lire les boutons poussoirs. L'écran LCD prend en charge le réglage du contraste et les fonctions d'activation / désactivation du rétro-éclairage. Il étend également les broches non utilisées autour de l’écran pour pouvoir les réutiliser.

 

 

d - où peut-on se procurer cette technologie ?

 

La programmation sur ces écrans ne requiers aucun pré requis, ici on utilisera un Shield LCD KeyPad Arduino mais les afficheurs doté des pins 1 à 7 du schéma ci-dessus peuvent marcher avec n'importe quel ordinateur/microcontrôleur.

Bien qu'étant fait avec utilisation d'un Arduino en tête, Arduino ne produisent pas leur modules mais il est possible de les trouver chez des revendeurs.

 

2 - Exemples d'applications

Pour cet exemple nous allons créer un programme simple qui va nous permettre d'afficher sur un lcd des menu navigable à l'aide de boutons.

Configuration des boutons

 

Comme dit précédemment, au lieu d’utiliser cinq pins digitaux, le Shield utilise uniquement le pin analogique A0, ce pin est équipé d’un CAN de type « Convertisseur à approximations successives ». Le CAN récupère un signale analogique de 0V à 5V et le convertis en un mot binaire de 0 à 1023. Le fonctionnement est simple, nous avons des boutons branché en parallèle avec une résistance différente à chaque entrée, quand on appuie sur un des boutons, on ferme le circuit et le 5V de l’Arduino va passer à travers toutes les résistances du circuit. De là, on utilisera un pont diviseur pour calculer la tentions de chaque boutons et avec ces valeurs il nous restera qu’à faire une règle de trois avec la valeur max du mot binaire (1023).

Chaque boutons aura donc une valeur différente ce qui nous permet d’avoir cinq boutons bien distinct les uns des autre et donc de pouvoir les programmer dans l’Arduino pour qu’il ait une fonction propre à eu même tout ça en utilisant qu’un seul pin.

Au niveau programme on pourra dire par exemple que : si le mot binaire est inférieur à 50, le bouton droit est pressé.

 

 

Écran LCD 16x2

C’est la partie principale du Shield LCD KeyPad, cet écran est de type « Cristaux liquides monochromes », ces écrans utilisent la polarisation de la lumière par des filtres polarisants dont on peut faire varier l’orientation en fonction du champ électrique. Du point de vue optique, l’écran à cristaux liquides est un dispositif passif : il n’émet pas de lumière, seule sa transparence varie, et il doit donc disposer d'un éclairage, le Shield dispose donc d’un panneau de DEL qui fournissent un éclairage rétro éclairé.

 

L’écran LCD dispose d’un contrôleur de points matriciel ST7066 de Sitronix qui contrôle chaque pixels de l’écran et qui permet la programmation de l’écran sur un microcontrôleur de 4 ou 8 bits, parmi ses fonctionnalités il nous est possible de d’afficher des caractères ascii, de créer de nouveau caractères, ou d’utiliser des instructions diverse comme du scrolling de texte, positionnement du curseur etc…

Charte des symboles Ascii 

La masse, le 5V et VO sont relié à un potentiomètre

Et ont ainsi pour fonction de contrôler le contraste de

L’écran, la broche RS « sélection de registre », permet

De changer entre le mode « instruction » et l’écriture

De symboles ascii et sera connecté au pin digital 8 de

L’Arduino, R/W nous permet de choisir entre envoyer

Des données au LCD ou d’en envoyer depuis l’écran,

Ce pin sera relié à la masse pour le maintenir en état

Bas ce qui correspond à uniquement envoyer des

Données au LCD, par la suite nous avons les pins de

Données que l’on passe à l’état HAUT ou BAS pour

Créer un mot binaire, ce mot binaire peut correspondre

À une instruction, ou à des symboles Ascii, pour le projet

On utilisera seulement quatre de ces pins la seule différence

Et qu’au lieu d’envoyer le mot binaire directement,

On enverra la première partie du mot puis

L’autre à la suite, le pin EN qui envoie le mot binaire à

L’écran afin de l’exécuter et qui sera relié au pin D9, et

Pour finir, les pins LED+ et LED- qui gèrent le rétro éclairage.

 

3 - Phase d'expérimentation 

a - description du cas d'étude et des résultats attendus

Au niveau programmation, les menus sont des fonctions contenues dans la boucle principale qui correspondent à différents écrans avec des instructions qui par la manipulation des boutons va rediriger la boucle d’un état à l’autre en incrémentant ou décrémentant une variable « menu » attaché à chacune des fonctions. De ce fait, si par exemple si l’utilisateur est dans le menu principal (menu=0), la pression du bouton droit peut avoir comme effet d’incrémenter la variable menu de 1 (menu=1) ainsi changeant d’écran, par exemple le mode manuel.

 

b - programmation

 

  • #include <LiquidCrystal.h> // Utilise la bibliotech LiquidCrystal
  • #include <RotaryEncoder.h>
  • LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

 

  • // Selectionne les pins utilisées pour le LCD (rs, enable, d4, d5, d6, d7

 

  • #define encoder0PinA 18 // Pin de l'encodeur n°1 horaire AttachInterrupt
  • #define encoder0PinB 19 // Pin de l'encodeur n°1 anti-horaire
  • #define encoder0PinC 20 // Pin de l'encodeur n°2 AttachInterrupt
  • #define encoder0PinD 21  // Pin de l'encodeur n°2 anti-horaire
  • #define btnRIGHT 0                   // Mappage des boutons
  • #define btnUP 1
  • #define btnDOWN 2
  • #define btnLEFT 3
  • #define btnSELECT 4
  • #define btnNONE 5
  • #define in1 24                             // Moteur n°1
  • #define in2 26                             // Moteur n°1
  • #define in3 28                             // Moteur n°2
  • #define in4 30                             // Moteur n°2
  • int menu = 0;                            // Var ref pour changement de menu
  • int adc_key_in = 0;                       // Lire les valeurs du CAN
  • int lcd_key = 0;                           // Défini des valeurs utilisé par le LCD et le keypad
  • int degreeSp = 0;                        // Map de L'azimut
  • int degreeSp1 = 0;                       // Map de L'elevation
  • long encoder0Pos = 0;                   // Incrementation de l'encodeur n°1
  • long encoder0Pos1 = 0;                 // Incrementation de l'encodeur n°2

 

  • int read_LCD_buttons() // Lit les boutons du shield keypad
  • {
  • adc_key_in = analogRead(0);  // Lit les valeurs du snignal analogique
  • if (adc_key_in > 1000) return btnNONE; // Attribue des tentions à des bp
  • if (adc_key_in < 50) return btnRIGHT;
  • if (adc_key_in < 250) return btnUP;
  • if (adc_key_in < 450) return btnDOWN;
  • if (adc_key_in < 650) return btnLEFT;
  • if (adc_key_in < 850) return btnSELECT;
  • return btnNONE; // Si aucun bp n'est pressé renvoie none
  • }

 

  • ////////////////////////////////////Au lancement /////////////////////////////////////////////
  • void setup()
  • {
  • begin(16, 2);                                              // Initialise l'écran LCD à 16 colonnes et 2 lignes
  • createChar(0, upArrow);                     // Crée le byte pour 4 nouveaux caractères
  • createChar(1, downArrow);
  • createChar(2, rightArrow);
  • createChar(3, leftArrow);
  • clear();
  • setCursor(3,0);                                // Définit la position du curseur
  • print("Bienvenue");
  • delay(2500);
  • clear();
  • pinMode(in1, OUTPUT);                            // Initialization des pins
  • pinMode(in2, OUTPUT);
  • pinMode(in3, OUTPUT);
  • pinMode(in4, OUTPUT);
  • pinMode(encoder0PinA, INPUT_PULLUP);
  • pinMode(encoder0PinB, INPUT_PULLUP);
  • attachInterrupt(3, doEncoder, RISING);
  • pinMode(encoder0PinC, INPUT_PULLUP);
  • pinMode(encoder0PinD, INPUT_PULLUP);
  • attachInterrupt(5, doEncoder1, RISING);
  • }

 

 

  • /////////////////////////////////////Chaine principale /////////////////////////////////////////
  • void loop()
  • {
  • if (menu==0)
  • {
  • setCursor(0,0);            // placer le curseur à la première ligne, première position
  • print("Elevation/Azimut"); // texte à afficher
  • setCursor(2,1);            // placer le curseur au début de la seconde ligne
  • print("Auto  Manuel");
  • setCursor(0,1);
  • write(byte(3));            // Affiche à l'écran le caractère 3
  • setCursor(15,1);
  • write(byte(2));            // Affiche à l'écran le caractère 2
  • lcd_key = read_LCD_buttons();  // lire la valeur du bouton (->fonction)
  • switch (lcd_key) // selon le bouton appuyé ...
  • {
  • case btnRIGHT:
  • {
  • menu=menu+2;
  • clear();
  • print("//MODE: MANUEL//");
  • setCursor(0,1);                          // placer le curseur au début de la seconde ligne
  • print("////////////////");
  • delay(1500);
  • clear();
  • setCursor(0,0);
  • print("Ajust. Manuel");
  • break;
  • }
  • case btnLEFT:
  •               {
  • menu=menu+1;
  • clear();
  • print("///MODE: AUTO///");
  • setCursor(0,1);
  • print("////////////////");
  • delay(1500);
  •  clear();
  • break;
  • }
  • }
  • }

 

  • if (menu==1)
  • {
  • setCursor(0,0);
  • print("Elevation/Azimut");
  • setCursor(0,1);                    // placer le curseur au début de la seconde ligne
  • print("Ajust. Auto");         // texte d'accueil
  • lcd_key = read_LCD_buttons();  // lire la valeur du bouton (->fonction)
  • switch (lcd_key) // selon le bouton appuyé ...
  • {
  • case btnSELECT:
  • {
  • menu=menu+2;
  • clear();
  • break;
  • }
  • }
  • }

 

  • if (menu==3)
  • {
  •  print("Quit.Ajust.Auto?");
  • setCursor(3,1);            // placer le curseur au début de la seconde ligne
  • print("OUI    NON");
  • setCursor(0,1);
  • write(byte(3));
  • setCursor(15,1);
  • write(byte(2));
  • lcd_key = read_LCD_buttons();  // lire la valeur du bouton (->fonction)
  • switch (lcd_key)
  • {
  • case btnLEFT:
  • {
  • menu=menu-3;
  • delay(500);
  • clear();
  • break;
  • }
  • case btnRIGHT:
  • {
  • menu=menu-2;
  • clear();
  • break;
  • }
  • }
  • }

 

  • if (menu==2)
  • {
  • setCursor(0,1);
  • lcd_key = read_LCD_buttons();  // lire la valeur du bouton (->fonction)
  • write(byte(3));
  • write(byte(2));
  • setCursor(3,1);
  • print(degreeSp);
  • print(" ");
  • setCursor(8,1);
  • write(byte(1));
  • write(byte(0));
  • setCursor(11,1);
  • print(degreeSp1);
  • print(" ");
  • switch (lcd_key)               // selon le bouton appuyé ...
  • {
  • case btnUP:
  • {
  • digitalWrite(in1, LOW);
  • digitalWrite(in2, HIGH);
  • break;
  • }
  • case btnDOWN:
  • {
  • digitalWrite(in1, HIGH);
  • digitalWrite(in2, LOW);
  • break;
  • }
  • case btnLEFT:
  • {
  • digitalWrite(in3, LOW);
  • digitalWrite(in4, HIGH);
  • break;
  • }
  • case btnRIGHT:
  • {
  • digitalWrite(in3, HIGH);
  • digitalWrite(in4, LOW);
  • break;
  • }
  • case btnSELECT:
  • {
  • menu=menu-2;
  • clear();
  • break;
  • }
  • case btnNONE:
  • {
  • digitalWrite(in1, LOW);
  • digitalWrite(in2, LOW);
  • digitalWrite(in3, LOW);
  • digitalWrite(in4, LOW);
  • break;
  • }
  • }
  • }
  • }

0 thoughts on “Programmation d’un afficheur LCD sur Arduino”

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *