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 |

Test de l'affichage sur un afficheur LCD graphique 128x64

ARDUINO - INITIATION - LCD GRAPHIQUE
Par X. HINAULT - Créé le 03/02/2010

1.  Présentation

Ce programme teste l'affichage sur un afficheur LCD graphique.Ce programme montre comment afficher des points et des figures simples sur un afficheur LCD graphique.

Source technique : Datasheet de l'afficheur 128x64 basé sur le CI KS0108
Librairie LCD graphique pour Arduino : http://www.arduino.cc/playground/Code/GLCDks0108

Ce programme utilise les fonctionnalités suivantes :

  • un afficheur LCD Graphique 128x64

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.  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 64x64) :
    • 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

5.  Le schéma théorique du montage


Le schéma théorique du montage

6.  Le circuit du montage


Le schéma du montage à réaliser

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.

Le déroulement du programme

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 128x64 :

#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)   

Le brochage que nous utilisons ici est différent du brochage par défaut fourni avec la librairie. Il faut modifier le fichier ks0108_Arduino.h en conséquence.

Déclaration de constantes utiles

  • On déclare les constantes utiles dans le programme :

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)

Déclaration des variables globales

  • Déclaration des variables globales du programmes : on déclare une variable de boucle.
int i=0; // variable de boucle

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

  • Déclaration des objets utiles pour les fonctionnalités utilisées :

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 :

  • Les broches utilisée avec le LCD sont configurées lors de l'initialisation du LCD graphique.

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

  • On commence par tracer une série de points ce qui dessine une ligne :

for (i=0; i<100; i++) {

 GLCD.SetDot(i, i/2, BLACK); // affiche un point de la couleur (BLACK/WHITE) à la position x,y indiquée
 delay(100); // pause 
}

  • Une fois fait, on efface l'écran puis on trace un rectangle. Puis on réalise une pause de 3 secondes avant d'effacer l'écran.

GLCD.ClearScreen();  // efface l'écran 

GLCD.DrawRect(32, 32, 50, 30, BLACK); //dessine un rectangle

delay (3000); // pause de 3 secondes avant recommencer

GLCD.ClearScreen();  // efface l'écran 

  • 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 dessin programmé s'affiche à l'écran.

12.  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 ? ---
/* Test l'affichage sur un afficheur LCD graphique*/

// --- Fonctionnalités utilisées ---
// Utilise un afficheur LCD Graphique 128x64

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

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


// --- Déclaration des variables globales ---
int i=0; // variable de boucle

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

for (i=0; i<100; i++) {


 GLCD.SetDot(i, i/2, BLACK); // affiche un point de la couleur (BLACK/WHITE) à la position x,y indiquée
 delay(100); // pause 
}

GLCD.ClearScreen();  // efface l'écran 

GLCD.DrawRect(32, 32, 50, 30, BLACK); //dessine un rectangle

delay (3000); // pause de 3 secondes avant recommencer

GLCD.ClearScreen();  // efface l'écran 


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

// --- Fin programme ---

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


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