View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

Afficher sur un LCD les touches appuyées sur un clavier

ARDUINO - EXPERT - LCD- CLAVIER
Par X. HINAULT - Créé le 03/02/2010

Le schéma du montage à réaliser (cliquer pour agrandir)

1.  Présentation

Ce programme affiche sur un LCD les touches tapées sur un clavier matriciel.Ce programme montre comment afficher les touches appuyées sur un clavier 4x4 sur un afficheur LCD, à l'aide de la librairie Arduino pour clavier matriciel (keypad en anglais).

Page de la librairie Arduino pour clavier matriciel : http://www.arduino.cc/playground/Code/Keypad . A noter que cette librairie n'est pas installée par défaut et qu'il faut la télécharger, la dézipper et copier/coller le répetoire keypad dans le répertoire Arduino>Hardware>Libraries> et relancer le logiciel Arduino pour prise en compte.

Note technique : la librairie Keypad se charge de mettre les broches de colonnes en SORTIE et les broches de lignes en ENTREE avec activation du « pull-up » interne.

Ce programme utilise les fonctionnalités suivantes :

  • un afficheur LCD alphanumérique 4x20 en mode 4 bits
  • un Clavier matriciel 4x4 (16 touches)

2.  Matériel Nécessaire

2.1  L'espace de développement Arduino

  • ... pour éditer, compiler le programme et programmer la carte Arduino.

2.2  Le matériel suivant pour réaliser le montage associé

3.  Instructions de montage

  • En ce qui concerne le Clavier matriciel 4x4 :
    • Connecter sur la broche 2 la Colonne 4 du Clavier
    • Connecter sur la broche 3 la Colonne 3 du Clavier
    • Connecter sur la broche 4 la Colonne 2 du Clavier
    • Connecter sur la broche 5 la Colonne 1 du Clavier
    • Connecter sur la broche 16 la Ligne 4 du Clavier
    • Connecter sur la broche 17 la Ligne 3 du Clavier
    • Connecter sur la broche 18 la Ligne 2 du Clavier
    • Connecter sur la broche 19 la Ligne 1 du Clavier
  • En ce qui concerne l'afficheur LCD :
    • Connecter sur la broche 8 la broche RS du LCD
    • Connecter sur la broche 9 la broche E du LCD
    • Connecter sur la broche 10 la broche D4 du LCD
    • Connecter sur la broche 11 la broche D5 du LCD
    • Connecter sur la broche 12 la broche D6 du LCD
    • Connecter sur la broche 13 la broche D7 du LCD

4.  Le schéma théorique du montage


Le schéma théorique du montage

Note Technique :

  • Lors de l'utilisation du clavier, la question se pose de mettre ou non des résistances de limitation de courant sur les broches de colonnes et de lignes... En consultant plusieurs notes d'applications de chez Atmel (fabricant de l'ATmega328 et autres), on retrouve des exemples sans résistances et de plus, dans un cas où des résistances sont utilisées il est indiqué qu'elles ont pour but d'éviter les décharge électro-satiques (ESD) et qu'elles peuvent-être omises dans la grande majorité des cas.
  • Par contre, il faut activer le « rappel au plus » interne sur toutes les broches de lignes qui sont en entrée.... ce qui est fait par la librairie keypad lors de l'initialisation.

5.  Le circuit du montage

Le schéma du montage à réaliser (cliquer pour agrandir)

6.  Explication du programme

6.1  Structure globale du programme

Ce programme simple comprend :

  • une entête déclarative
  • une partie « configuration » qui ne sera exécutée qu'une fois (fonction setup( ) )
  • une partie constituée d'une boucle sans fin que le programme répètera à l'infini ( fonction loop( ) ) : c'est le coeur du programme.

6.2  Déroulement du programme

Le programme se déroule de la façon suivante :

  • Après avoir pris en compte les instructions de la partie déclarative,
  • puis après avoir exécuté la partie configuration ( fonction setup( ) ),
  • le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.

Le déroulement du programme

7.  Au niveau de la partie déclarative :

Inclusion des librairies utilisées

  • On inclut les librairies des fonctionnalités utilisées :
    • Inclusion de la librairie pour l'afficheur LCD alphanumérique :

#include <LiquidCrystal.h> // Inclusion de la librairie pour afficheur LCD
 
  • Inclusion de la librairie pour le clavier matriciel :

#include <Keypad.h> // inclusion de la librairie pour clavier matriciel
 

Déclaration de constantes utiles

  • On déclare les constantes utiles dans le programme :
    • Déclaration des constantes utiles pour l'utilisation du clavier 4x4 :

//--- Constantes utilisées avec le clavier 4x4
const byte LIGNES = 4; // 4 lignes
const byte COLONNES = 4; //4 colonnes
 

Déclaration des constantes de broches

  • Déclaration des constantes pour les broches utilisées dans le programme :

const int C4=2; //declaration constante de broche
const int C3=3; //declaration constante de broche
const int C2=4; //declaration constante de broche
const int C1=5; //declaration constante de broche
const int RS=8; //declaration constante de broche
const int E=9; //declaration constante de broche
const int D4=10; //declaration constante de broche
const int D5=11; //declaration constante de broche
const int D6=12; //declaration constante de broche
const int D7=13; //declaration constante de broche
const int L4=16; //declaration constante de broche
const int L3=17; //declaration constante de broche
const int L2=18; //declaration constante de broche
const int L1=19; //declaration constante de broche
 

Déclaration des variables globales

  • Déclaration des variables globales du programmes :
    • Déclaration variables globales des touches du clavier 4x4

//--- Définition des touches
char touches[LIGNES][COLONNES] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
 
  • Déclaration variables globales de lignes et de colonnes du clavier 4x4 et de la variable de mémorisation de la touche appuyée
// tableaux de lignes et colonnes
byte BrochesLignes[LIGNES] = {L1, L2, L3, L4}; //connexions utilisées pour les broches de lignes du clavier
byte BrochesColonnes[COLONNES] = {C1, C2, C3, C4}; //connexions utilisées pour les broches de colonnes du clavier

char touche; // variable de stockage valeur touche appuyée
 

Déclarations des objets utiles pour les fonctionnalités utilisées

  • Déclaration des objets utiles pour les fonctionnalités utilisées :
    • Déclaration d'un objet LCD alphanumérique :

LiquidCrystal lcd(RS, E, D4, D5, D6, D7);// Création d'un objet LiquidCrystal = initialisation LCD en mode 4 bits
 
  • Déclaration d'un objet clavier matriciel :

// création d'un objet keypad = initialisation clavier
Keypad clavier = Keypad( makeKeymap(touches), BrochesLignes, BrochesColonnes, LIGNES, COLONNES );
// les broches de lignes sont automatiquement configurées en ENTREE avec pullup interne activé
// les broches de colonnes sont automatiquement configurées en SORTIE
 

8.  Au niveau de la fonction d'initialisation setup( ) :

Initialisation des fonctionnalités utilisées :

  • On initialise les différentes fonctionnalités utilisées :
    • Initialisation de l'utilisation de l'afficheur LCD alpha-numérique

lcd.begin(20,4); // Initialise le LCD avec 20 colonnes x 4 lignes

delay(10); // pause rapide pour laisser temps initialisation
 
  • Test de l'afficheur LCD alpha-numérique

// Test du LCD

lcd.print("LCD OK") ; // affiche la chaîne texte - message de test
delay(2000); // pause de 2 secondes

lcd.clear(); // // efface écran et met le curseur en haut à gauche
delay(10); // pour laisser temps effacer écran
 

configuration des broches utilisées :

  • Les broches de lignes et d'entrée sont configurées automatiquement lors de l'initialisation du clavier
  • Configuration des broches en sortie : la configuration des broches du clavier et du LCD clavier se fait automatiquement lors l'initialisation.
  • Configuration des broches en entrée : la configuration des broches du clavier se fait automatiquement lors l'initialisation.
  • Activation du rappel au + interne des broches en entrée si nécessaire : l'activation du pullup des broches de lignes du clavier se fait automatiquement lors l'initialisation.

9.  Au niveau de la boucle principale, la fonction loop ( ) :

  • On commence par "lire" la touche appuyée

touche = clavier.getKey(); // lecture de la touche appuyée
 
  • Ensuite, on teste si une touche a été appuyée et on réalise l'affichage de la touche appuyée.
  • L'appui sur le # entraîne l'effacement du clavier.

if (touche != NO_KEY){ // si une touche a été frappée -- gestion de la touche appuyée

  if (touche=='#') lcd.clear(); else lcd.print(touche); // efface écran si appui # sinon  affiche touche
  delay(300); // pause entre 2 appuis

} // fin gestion de la touche appuyée
 
  • Le programme recommence en boucle les instructions de la fonction loop( ).

Se reporter aux commentaires présents dans le programme pour plus de détails.

10.  Mise en oeuvre du programme

10.1  Préparation du montage et programmation de la carte Arduino :

  • Commencer par réaliser le montage indiqué sur plaque d'expérimentation
  • Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle

10.2  Fonctionnement

  • Les touches appuyées s'affichent sur le LCD et l'appui sur le # efface l'écran.

11.  Le programme complet en langage Arduino :

A copier/coller directement dans l'éditeur Arduino


// --- Programme Arduino ---
// par X. HINAULT - 01/2010
// www.mon-club-elec.fr

// --- Que fait ce programme ? ---
/* Affiche sur un LCD les touches tapées sur un clavier matriciel*/

// --- Fonctionnalités utilisées ---
// Utilise un afficheur LCD alphanumérique4x20 en mode 4 bits
// Utilise un Clavier matriciel 4x4 (16 touches)

// --- Circuit à réaliser ---
// Connecter  sur la broche 2 la Colonne 4 du Clavier
// Connecter  sur la broche 3 la Colonne 3 du Clavier
// Connecter  sur la broche 4 la Colonne 2 du Clavier
// Connecter  sur la broche 5 la Colonne 1 du Clavier

// Connecter  sur la broche 8 la broche RS du LCD
// Connecter  sur la broche 9 la broche E du LCD
// Connecter  sur la broche 10 la broche D4 du LCD
// Connecter  sur la broche 11 la broche D5 du LCD
// Connecter  sur la broche 12 la broche D6 du LCD
// Connecter  sur la broche 13 la broche D7 du LCD

// Connecter  sur la broche 16 la Ligne 4 du Clavier
// Connecter  sur la broche 17 la Ligne 3 du Clavier
// Connecter  sur la broche 18 la Ligne 2 du Clavier
// Connecter  sur la broche 19 la Ligne 1 du Clavier

//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables...

// --- Inclusion des librairies utilisées ---

#include <LiquidCrystal.h> // Inclusion de la librairie pour afficheur LCD

#include <Keypad.h> // inclusion de la librairie pour clavier matriciel

// --- Déclaration des constantes ---

//--- Constantes utilisées avec le clavier 4x4
const byte LIGNES = 4; // 4 lignes
const byte COLONNES = 4; //4 colonnes


// --- constantes des broches ---

const int C4=2; //declaration constante de broche
const int C3=3; //declaration constante de broche
const int C2=4; //declaration constante de broche
const int C1=5; //declaration constante de broche
const int RS=8; //declaration constante de broche
const int E=9; //declaration constante de broche
const int D4=10; //declaration constante de broche
const int D5=11; //declaration constante de broche
const int D6=12; //declaration constante de broche
const int D7=13; //declaration constante de broche
const int L4=16; //declaration constante de broche
const int L3=17; //declaration constante de broche
const int L2=18; //declaration constante de broche
const int L1=19; //declaration constante de broche

// --- Déclaration des variables globales ---

//--- Définition des touches
char touches[LIGNES][COLONNES] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};

// tableaux de lignes et colonnes
byte BrochesLignes[LIGNES] = {L1, L2, L3, L4}; //connexions utilisées pour les broches de lignes du clavier
byte BrochesColonnes[COLONNES] = {C1, C2, C3, C4}; //connexions utilisées pour les broches de colonnes du clavier

char touche; // variable de stockage valeur touche appuyée


// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---

LiquidCrystal lcd(RS, E, D4, D5, D6, D7);// Création d'un objet LiquidCrystal = initialisation LCD en mode 4 bits


// création d'un objet keypad = initialisation clavier
Keypad clavier = Keypad( makeKeymap(touches), BrochesLignes, BrochesColonnes, LIGNES, COLONNES );
// les broches de lignes sont automatiquement configurées en ENTREE avec pullup interne activé
// les broches de colonnes sont automatiquement configurées en SORTIE


//**************** FONCTION SETUP = Code d'initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// --- ici instructions à exécuter au démarrage ---

lcd.begin(20,4); // Initialise le LCD avec 20 colonnes x 4 lignes

delay(10); // pause rapide pour laisser temps initialisation

// Test du LCD

lcd.print("LCD OK") ; // affiche la chaîne texte - message de test
delay(2000); // pause de 2 secondes

lcd.clear(); // // efface écran et met le curseur en haut à gauche
delay(10); // pour laisser temps effacer écran



// les broches de lignes et d'entrée sont configurées automatiquement lors de l'initialisation du clavier

// ------- Broches en sortie -------  


// ------- Broches en entrée -------  


// ------- Activation du rappel au + interne des broches en entrée si nécessaire -------  


} // fin de la fonction setup()
// ********************************************************************************

//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ // debut de la fonction loop()

// --- ici instructions à exécuter par le programme principal ---

touche = clavier.getKey(); // lecture de la touche appuyée

if (touche != NO_KEY){ // si une touche a été frappée -- gestion de la touche appuyée

  if (touche=='#') lcd.clear(); else lcd.print(touche); // efface écran si appui # sinon  affiche touche
  delay(300); // pause entre 2 appuis

} // fin gestion de la touche appuyée

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

// --- Fin programme ---

// --- Mémo instructions ---

// var_int = digitalRead(Pin); //lit état de la broche indiquée et renvoie valeur HIGH ou LOW
// digitalWrite(pin, value) ; // met la valeur HIGH ou LOW sur la broche indiquée
// digitalRead(pin) ; // lit l'état d'une broche numérique en entrée et renvoie la valeur HIGH ou LOW présente sur la broche
// --- Impulsions ---
// analogWrite(broche,largeur); // génère une impulsion PWM sur la broche de largeur 0 (0%) à 255 (100%)

// tone(broche, frequence, +/-duree); // produit son de fréquence indiquée sur la broche
// noTone(broche); // stoppe la production de son sur la broche
// à noter : une seule broche peut générer un son à la fois...

// --- mémo boucle --
//for (int i=0; i <= 10; i++); // boucle simple
//delay(300); // pause en millisecondes

// ----- memo LCD ---
// LiquidCrystal(rs, enable, d4, d5, d6, d7) ; // initialisation 4 bits
// lcd.begin(cols, rows); // initialisation nombre colonne/ligne
//
// lcd.clear(); // efface écran et met le curseur en haut à gauche
// lcd.home(); // repositionne le curseur en haut et à gauche SANS effacer écran
//
// lcd.setCursor(col, row) ; // positionne le curseur à l'endroit voulu (colonne, ligne) (1ère=0 !)
// lcd.print("texte") ; // affiche la chaîne texte
//
// lcd.cursor() ; // affiche la ligne de base du curseur
// lcd.noCursor() ; // cache le curseur
// lcd.blink() ; // fait clignoter le curseur
// lcd.noBlink() ;// stoppe le clignotement du curseur
// lcd.noDisplay() ; // éteint le LCD sans modifier affichage
// lcd.display() ; // rallume le LCD sans modif affichage
//
// lcd.scrollDisplayLeft(); // décale l'affichage d'une colonne vers la gauche
// lcd.scrollDisplayRight(); // décale l'affichage d'une colonne vers la droite
// lcd.autoscroll() ; // les nouveaux caractères poussent les caractères déjà affichés
// noAutoscroll(); // stoppe le mode autoscroll

//---------- Mémo Clavier - librairie Keypad ---------
// var=char getKey(); // renvoie la valeur de la touche
// touche = clavier.getKey(); // lecture de la touche appuyée
//
//
//
//
//
//