// 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 4×4 sur la broche 5
// Connecter broche de colonne C2 du clavier 4×4 sur la broche 4
// Connecter broche de colonne C3 du clavier 4×4 sur la broche 3
// Connecter broche de colonne C4 du clavier 4×4 sur la broche 2

// Connecter broche de ligne L1 du clavier 4×4 sur la broche 19
// Connecter broche de ligne L2 du clavier 4×4 sur la broche 18
// Connecter broche de ligne L3 du clavier 4×4 sur la broche 17
// Connecter broche de ligne L4 du clavier 4×4 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 4×4
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 ////////////////////