Affichage d’une mesure analogique continue sous forme de courbe sur un afficheur LCD graphique 128×64.

1.  Présentation

Ce programme affiche le résultat d’une conversion analogique numérique sous forme graphique
sur un afficheur LCD graphique 128×64, réalisant un oscilloscope basique. On remarquera une fois de plus que le langage Arduino permet un tel résultat en quelques lignes de programme seulement.

Ce programme utilise les fonctionnalités suivantes :

• un afficheur LCD Graphique 128×64
• la conversion analogique numérique 10bits sur les voies analogiques analog 0,

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,

• une résistance variable linéaire de 10 KOhms,

• un afficheur LCD graphique (basé sur ks0108)préparé pour une utilisation simplifiée? avec la carte Arduino.

3.  Brochage type d’un afficheur LCD Graphique :

Un afficheur LCD graphique présente typiquement les 20 broches suivantes :

On distingue :

• les broches d’alimentation :
  • 1 (GND) : 0V
  • 2 (VCC): +5V
  • 3 (VO) : Tension de contraste
  • 18 (VEE) : Tension négative pour contraste. Ces 2 broches 3: (VO) et 18: (VEE) doivent être montées de la façon suivante à l’aide d’une résistance variable :

• 19 : Anode de la LED de rétro-éclairage (si dispo)
• 20 : Cathode de la LED de rétro-éclairage (si dispo)

• les broches logiques de commandes du LCD :
  • 4 (D/I) : (équivalent RS ) Data/Instruction qui indique si les données sont une donnée ou une instruction
  • 5 (R/W) : Read/Write qui indique si le LCD fonctionne en Ecriture ou en Lecture
  • 6 (E) : Enable qui valide la prise en compte des données
  • 17 (/Reset) : Broche de réinitialisation sur niveau Bas
• les broches logiques de sélection de la partie d’écran utilisée (chaque bloc fait 64×64) :
  • 15 (CS1) : Chip Select 1
  • 16 (CS2) : Chip Select 2
• les broches logiques de données :
  • 7-14 (D0-7) : Broches de données.

4.  Instructions de montage

• Connecter sur la broche 4 la broche D4 du LCD Graphique
• Connecter sur la broche 5 la broche D5 du LCD Graphique
• Connecter sur la broche 6 la broche D6 du LCD Graphique
• Connecter sur la broche 7 la broche D7 du LCD Graphique
• Connecter sur la broche 8 la broche D0 du LCD Graphique
• Connecter sur la broche 9 la broche D1 du LCD Graphique
• Connecter sur la broche 10 la broche D2 du LCD Graphique
• Connecter sur la broche 11 la broche D3 du LCD Graphique
• Connecter sur la broche 12 la broche CS1 du LCD Graphique
• Connecter sur la broche 13 la broche CS2 du LCD Graphique
• Connecter sur la broche 16 la broche D/I du LCD Graphique
• Connecter sur la broche 17 la broche R/W du LCD Graphique
• Connecter sur la broche 18 la broche E du LCD Graphique
• Connecter sur la broche 19 la broche Reset du LCD Graphique
• Broche Analog 0 (=broche 14) en entrée Analogique : connecter une résistance variable entre le 0 et 5V.

5.  Le schéma théorique du montage

6.  Le circuit du montage

7.  Explication du programme

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

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

8.  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 Graphique 128×64 :

#include <ks0108.h> // Librairie pour afficheur LCD Graphique 128x64 basé sur CI ks0108 ou équiv
// Librairie à télécharger à l'adresse : http://www.arduino.cc/playground/Code/GLCDks0108
// Modifier au besoin la définition des broches utilisée dans fichier ks0108_Arduino.h ou ks0108_Mega
//#include <Arial14.h>  // Définition police pour Arial 14 point
//#include "SystemFont5x7.h"   // système de police utilisé
//#include "ArduinoIcon.h"     // fichier image bitmap   
//Pour mémoire : le coin gauche supérieur a pour coordonnées (0,0)   

Déclaration des constantes de broches

• Déclaration des constantes pour les broches utilisées dans le programme :
  • Les broches utilisées avec le LCD graphique sont déclarées par la fonction GLCD.init (voir setup)

const int Voie_0=0; //declaration constante de broche analogique

Déclaration des variables globales

• Déclaration des variables globales du programmes :
  • Déclaration des variables globales utilisées pour la conversion analogique-numérique

int mesure_brute=0;// Variable pour acquisition résultat brut de conversion analogique numérique
float mesuref=0.0;// Variable pour calcul résultat décimal de conversion analogique numérique

• Déclaration de variables globales utilisées pour le tracé de la courbe

int x=0, y=0; // variable coordonnée point affiché sur LCD
int x0=0,y0=0; // variable coordonnée dernier point affiché sur LCD

9.  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’afficheur graphique :

GLCD.Init(NON_INVERTED);   // initialise la librairie LCD graphique - NON INVERTED = écran blanc avec dessin noir
GLCD.ClearScreen();  // efface l'écran 

configuration des broches utilisées :

• Configuration des broches en sortie : les broches utilisées avec l’afficheur sont configurées lors de l’initialisation de l’afficheur LCD graphique.
• Configuration des broches en entrée : la broche analogique n’a pas besoin d’être configurée en entrée.

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

• on commence par faire une mesure analogique et on réalise une adaptation de valeur pour s’adapter à la hauteur de l’écran LCD.

// lit la tension sur la broche et met le résultat brut (0-1023) dans la variable
mesure_brute=analogRead(Voie_0); 

// adapte échelle mesure 0-1023 à hauteur écran 0-63
y=map(mesure_brute,0,1023,0,63); 

• Ensuite on réalise le tracé de la courbe en effaçant au préalable l’affichage précédent :

// efface mesure affichage précédent
GLCD.DrawLine(x,0,x,63,WHITE); // dessine ligne de x1,y1 à x2,y2 

// affichage de la mesure
GLCD.DrawLine(x0,y0,x,y,BLACK); // dessine ligne de x1,y1 à x2,y2 

x0=x; y0=y; // mémorise point actuel

x++; // incrémente x à chaque passage
if (x>127) {
  x=0; // RAZ x de 127=>0
  x0=0; //réinitialise aussi x0 pour retour propre
}

delay (20); // entre 2 mesures

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

11.  Mise en oeuvre du programme

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

11.2  Fonctionnement

• Le tracé de la courbe s’affiche en continu sur l’afficheur LCD graphique réalisant un mini oscilloscope basse tension basse fréquence.

12.  Le programme complet en langage Arduino :

A copier/coller directement dans l’éditeur Arduino

// --- Programme Arduino ---
// par X. HINAULT - Le 24/02/2010
// www.mon-club-elec.fr 

// --- Que fait ce programme ? ---
/* affiche le résultat d'une conversion analogique numérique sous forme graphique 
sur un afficheur LCD graphique 128x64, réalisant un oscilloscope basique. */

// --- Fonctionnalités utilisées ---
// Utilise un afficheur LCD Graphique 128x64
// Utilise la conversion analogique numérique 10bits sur les voies analogiques  analog 0, 

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

// Connecter  sur la broche 4 la broche D4 du LCD Graphique
// Connecter  sur la broche 5 la broche D5 du LCD Graphique
// Connecter  sur la broche 6 la broche D6 du LCD Graphique
// Connecter  sur la broche 7 la broche D7 du LCD Graphique

// Connecter  sur la broche 8 la broche D0 du LCD Graphique
// Connecter  sur la broche 9 la broche D1 du LCD Graphique
// Connecter  sur la broche 10 la broche D2 du LCD Graphique
// Connecter  sur la broche 11 la broche D3 du LCD Graphique

// Connecter  sur la broche 12 la broche CS1 du LCD Graphique
// Connecter  sur la broche 13 la broche CS2 du LCD Graphique

// Connecter  sur la broche 16 la broche D/I du LCD Graphique
// Connecter  sur la broche 17 la broche R/W du LCD Graphique
// Connecter  sur la broche 18 la broche E du LCD Graphique
// Connecter  sur la broche 19 la broche Reset du LCD Graphique

// Broche Analog 0 (=broche 14) en entrée Analogique  : connecter une résistance variable entre le 0 et 5V. 

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

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

#include <ks0108.h> // Librairie pour afficheur LCD Graphique 128x64 basé sur CI ks0108 ou équiv
// Librairie à télécharger à l'adresse : http://www.arduino.cc/playground/Code/GLCDks0108
// Modifier au besoin la définition des broches utilisée dans fichier ks0108_Arduino.h ou ks0108_Mega
//Pour mémoire : le coin gauche supérieur a pour coordonnées (0,0)   

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

// --- constantes des broches ---


// Les broches utilisées avec le LCD graphique sont déclarées par la fonction GLCD.init (voir setup)

const int Voie_0=0; //declaration constante de broche analogique

// --- Déclaration des variables globales ---
int mesure_brute=0;// Variable pour acquisition résultat brut de conversion analogique numérique
float mesuref=0.0;// Variable pour calcul résultat décimal de conversion analogique numérique

int x=0, y=0; // variable coordonnée point affiché sur LCD
int x0=0,y0=0; // variable coordonnée dernier point affiché sur LCD


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

//**************** 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 --- 

GLCD.Init(NON_INVERTED);   // initialise la librairie LCD graphique - NON INVERTED = écran blanc avec dessin noir
GLCD.ClearScreen();  // efface l'écran 


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

// lit la tension sur la broche et met le résultat brut (0-1023) dans la variable
mesure_brute=analogRead(Voie_0); 

// adapte échelle mesure 0-1023 à hauteur écran 0-63
y=map(mesure_brute,0,1023,0,63); 

// efface mesure affichage précédent
GLCD.DrawLine(x,0,x,63,WHITE); // dessine ligne de x1,y1 à x2,y2 

// affichage de la mesure
GLCD.DrawLine(x0,y0,x,y,BLACK); // dessine ligne de x1,y1 à x2,y2 

x0=x; y0=y; // mémorise point actuel

x++; // incrémente x à chaque passage
if (x>127) {
  x=0; // RAZ x de 127=>0
  x0=0; //réinitialise aussi x0 pour retour propre
}

delay (20); // entre 2 mesures

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

// --- Fin programme ---

//--- Mémo LCD graphique ---

//GLCD.Init(invert) initialize the library for normal or inverted drawing. If invert is false,
// drawing sets pixels, if true pixels are cleared when drawn (see also SetInverted method) 
//GLCD.GotoXY(x,y) locate the graphic cursor at positions x and y, 0,0 is upper left corner
//GLCD.ClearScreen() clear the LCD screen

// Graphic Drawing Functions (color WHITE clears pixels, BLACK sets pixels)
//GLCD.DrawCircle(x, y, radius, color) draw circle with center at x,y
//GLCD.DrawLine(x1,y1,x2,y2,color) draw line from x1,y1 to x2,y2 
//GLCD.DrawVertLine(x, y, length, color) draw vertical line
//GLCD.DrawHoriLine(x, y, length, color) draw horizontal line
//GLCD.DrawRect(x, y, width, height, color) draw rectangle
//GLCD.DrawRoundRect(x, y, width, height, radius, color) as above with rounded edges
//GLCD.FillRect(x, y, width, height, color) draw filled rectangle
//GLCD.InvertRect(x, y, width, height) invert pixels within given rectangle
//GLCD.SetInverted(invert) set drawing mode to inverted 
//GLCD.SetDot(x, y, color); draw a dot in the given color at the given location
//GLCD.DrawBitmap(bitmap, x, y, color); draw the bitmap at the given x,y position

// Font Functions 
//GLCD.SelectFont(font, color ) select font, defaults color to black if not specified
//GLCD.PutChar(character) print given character to screen at current cursor location
//GLCD.Puts(string) print given string to screen at current cursor location
//GLCD.Puts_P(string) print string from program memory to screen at current cursor location
//GLCD.PrintNumber(number) print the decimal value of the given number at current cursor location
//GLCD.CursorTo(x, y); // 0 based coordinates for fixed width fonts (i.e. the supplied system font)