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 |

Saisir une valeur entière au clavier matriciel et l'afficher sur l'afficheur LCD 4x20

Par X. HINAULT - Page créée le : 12/2/2011.

(cliquer sur l'image pour agrandir)

1.  Présentation

Ce programme montre comment saisir au clavier matriciel une valeur numérique de type int et l'afficher sur l'afficheur LCD. Ce programme pourra servir de base pour des applications utilisant des claviers et afficheurs LCD.

La valeur maximale possible est 65535 (voir type int). La saisie est validée par l'appui sur # ou 5 chiffres saisis.

Ce programme utilise les fonctionnalités suivantes :

  • Utilise un afficheur LCD alphanumérique en mode 4 bits
  • Utilise un clavier matriciel 16 touches (4 colonnes x 4 lignes)

Ressources utiles associées à ce programme :

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é

  • une plaque d'essai pour montage sans soudures,
  • des straps,

3.  Instructions de montage

  • Connexion du LCD sur les broches de la carte Arduino :
    • Connecter broche RS du LCD sur la broche 8
    • Connecter broche E du LCD sur la broche 9
    • Connecter broche D4 du LCD sur la broche 10
    • Connecter broche D5 du LCD sur la broche 11
    • Connecter broche D6 du LCD sur la broche 12
    • Connecter broche D7 du LCD sur la broche 13
  • Connexion du clavier matriciel 16 touches (4 colonnes x 4 lignes) sur la carte Arduino
    • Connecter broche de colonne C1 du clavier 4x4 sur la broche 5
    • Connecter broche de colonne C2 du clavier 4x4 sur la broche 4
    • Connecter broche de colonne C3 du clavier 4x4 sur la broche 3
    • Connecter broche de colonne C4 du clavier 4x4 sur la broche 2
    • Connecter broche de ligne L1 du clavier 4x4 sur la broche 19
    • Connecter broche de ligne L2 du clavier 4x4 sur la broche 18
    • Connecter broche de ligne L3 du clavier 4x4 sur la broche 17
    • Connecter broche de ligne L4 du clavier 4x4 sur la broche 16

4.  Le schéma théorique du montage

Le schéma théorique du montage (cliquer pour agrandir)

5.  Le circuit du montage

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

6.  Fonctionnement 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.  Explication du programme

7.1  Au niveau de la partie déclarative :

  • Déclaration du tableau de touches

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

  • Initialisation de l'objet clavier et de l'objet LCD

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

  • On appelle une fonction dédiée pour la lecture du clavier et la saisie de la valeur

7.4  Fonction dédiée pour la lecture du clavier

  • A chaque appui, on analyse la valeur saisie et on calcule le nombre saisi
  • Si la touche # est appuyée ou si 5 chiffres sont saisis, on sort de la fonction en renvoyant la valeur saisie.

8.  Mise en oeuvre du programme

8.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

8.2  Fonctionnement

  • Saisir des chiffres au clavier : l'afficheur affiche le résultat.
  • La validation a lieu si la touche # est appuyée ou si 5 chiffres sont saisis.

9.  Le programme complet en langage Arduino

A copier/coller directement dans l'éditeur Arduino


// --- Programme Arduino ---
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr

// Auteur du Programme : X. HINAULT - Tous droits réservés
// Programme écrit le : 12/2/2011.

// ------- Licence du code de ce programme -----
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ////////////////////  PRESENTATION DU PROGRAMME ////////////////////

// -------- Que fait ce programme ? ---------
 /* Ce programme montre comment saisir au clavier matriciel une valeur numérique et l'afficher sur l'afficheur LCD. Ce programme pourra servir de base pour des applications utilisant des claviers et afficheurs LCD.  */

// --- Fonctionnalités utilisées ---

// Utilise un afficheur LCD alphanumérique en mode 4 bits
// Utilise un clavier matriciel 16 touches (4 colonnes x 4 lignes)  

// -------- Circuit à réaliser ---------

// Connexion du LCD sur les broches de la carte Arduino :
// Connecter broche RS du LCD sur la broche 8
// Connecter broche E du LCD sur la broche 9
// Connecter broche D4 du LCD sur la broche 10
// Connecter broche D5 du LCD sur la broche 11
// Connecter broche D6 du LCD sur la broche 12
// Connecter broche D7 du LCD sur la broche 13

// Connexion  du clavier matriciel 16 touches (4 colonnes x 4 lignes) sur la carte Arduino
// Connecter broche de colonne C1 du clavier 4x4 sur la broche 5
// Connecter broche de colonne C2 du clavier 4x4 sur la broche 4
// Connecter broche de colonne C3 du clavier 4x4 sur la broche 3
// Connecter broche de colonne C4 du clavier 4x4 sur la broche 2

// Connecter broche de ligne L1 du clavier 4x4 sur la broche 19
// Connecter broche de ligne L2 du clavier 4x4 sur la broche 18
// Connecter broche de ligne L3 du clavier 4x4 sur la broche 17
// Connecter broche de ligne L4 du clavier 4x4 sur la broche 16

// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles...

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

// --- Inclusion des librairies ---

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

#include <Keypad.h> // inclusion de la librairie pour clavier matriciel
// Avant utilisation, il faut installer manuellement cette librairie
// dans le dossier <Libraries> du dossier Arduino
// infos : www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.Main.LibrairieKeypad

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

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

// --- Déclaration des constantes des broches E/S numériques ---

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

// --- Déclaration des constantes des broches analogiques ---


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

//--- Définition des touches
char touches[LIGNES][COLONNES] = { // tableau de char à 2 dimensions
  {'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

unsigned int valeur; // variable pour valeur saisie

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

//------------ Création d'un objet afficheur LCD alphanumérique ----
LiquidCrystal lcd(RS, E, D4, D5, D6, D7);// 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


// ////////////////////////// 2. 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 1 seule fois au démarrage du programme ---

// ------- Initialisation fonctionnalités utilisées -------  

// Initialisation de l'afficheur LCD
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
lcd.print("LCD OK"); // affiche texte
delay (1000); //pause
lcd.clear(); // efface LCD

delay(10);
lcd.blink(); // active clignotement


// ------- Broches en sorties numériques -------  

// ------- Broches en entrées numériques -------  

// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques -------  

// ------- Initialisation des variables utilisées -------  

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

////////////////////////////////// 3. 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 ---

// ------ Code exemple lecture touche clavier matriciel --------

  valeur=SAISIE_uINT(); // appel de la fonction pour saisie valeur - # stoppe saisie
  lcd.setCursor(0,1); // se positionne en colonne,ligne
  lcd.print("                "); // efface ligne
  lcd.setCursor(0,1); // se positionne en colonne,ligne
  lcd.print("valeur : "); // affiche variable
  lcd.print(valeur); // affiche variable

  delay(500); // pause entre 2 saisies

  lcd.home(); // se positionne en 0,0
  lcd.print("                "); // efface ligne
  lcd.home(); // se positionne en 0,0



//while(1); // stop loop

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


// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////


// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////

unsigned int SAISIE_uINT (){ // fonction qui renvoie une valeur unsignedint (16bits)

//---- variables locales utilisées dans la fonction
unsigned char saisie_int[8]={0,0,0,0,0,0,0,0}; // crée un tableau de variables char pour saisir valeur
unsigned char compt_touche_int; // variable de comptage du nombre de touches saisies
unsigned long nombre_saisi_int; // variable de calcul du nombre saisi
unsigned char touche_int; // variable locale pour valeur touche appuyée de 0 à 15

//---- initialisation des variables utilisées ----
compt_touche_int=0; // aucune touche saisie au démarrage
nombre_saisi_int=0; // initialise la variable

//------ gestion appui touche sur clavier

 while (compt_touche_int<5) { // tant que pas appuis maxi = 5 pour int (valeur maxi=65535)

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

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


           if (touche_int=='#') break; // sort du while si appui sur #

           for (byte i=0;i<LIGNES;i++) {
             for (byte j=0; j<COLONNES;j++){

               if (touche_int==touches[i][j]) touche_int=touches[i][j]-48; // extrait valeur numérique à partir ASCII
             }
           }
           saisie_int[compt_touche_int]=touche_int; //enregistre le caractère dans tableau code_saisi
           lcd.print(char(saisie_int[compt_touche_int]+48)); // affiche valeur à emplacement actuel sur LCD

           compt_touche_int=compt_touche_int+1; // on incrémente la variable compt qui mémorise le nombre de caractères saisis

           //delay ()

           touche_int=255; // remet à 255 la variable touche... pour éviter prise en compte même appui à plusieurs reprises

         } //---- fin gestion appui clavier

}// fin du While = fin de la lecture du clavier

//--------- calcul valeur saisie en fonction du nombre de chiffres saisis ---------
if (compt_touche_int==0)nombre_saisi_int=0;   // si aucun chiffre saisi
if (compt_touche_int==1)nombre_saisi_int=saisie_int[0];   // si 1 seul chiffre saisi
if (compt_touche_int==2)nombre_saisi_int=(saisie_int[0]*10)+(saisie_int[1]*1);   // si 2 chiffres saisi
if (compt_touche_int==3)nombre_saisi_int=(saisie_int[0]*100)+(saisie_int[1]*10)+(saisie_int[2]*1);   // si 3 chiffres saisi
if (compt_touche_int==4)nombre_saisi_int=(saisie_int[0]*1000)+(saisie_int[1]*100)+(saisie_int[2]*10)+(saisie_int[3]*1);   // si 4 chiffres saisi
if (compt_touche_int==5)nombre_saisi_int=(saisie_int[0]*10000)+(saisie_int[1]*1000)+(saisie_int[2]*100)+(saisie_int[3]*10)+(saisie_int[4]*1);   // si 5 chiffres saisi

//------ à réaliser en sortie de lecture du clavier ----


compt_touche_int=0; // réinitialise le nombre de touche saisies

//----- renvoi de la valeur saisie ----

return (nombre_saisi_int); // renvoie la valeur - sortie de la fonction

}


// ////////////////////////// Fin du programme ////////////////////