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 |

Affichage simple de l'heure sur un module couleur S65 Shield

ARDUINO - EXPERT - TEMPORISATION - S65
Par X. HINAULT - Créé le 28/04/2010

1.  Présentation

Ce programme réalise un comptage des secondes (interruption du Timer2 toutes les secondes) et réalise un affichage de l'heure sur un module couleur TFT S65 Shield.

Ce programme utilise les fonctionnalités suivantes :

  • Utilise un afficheur TFT 65536 couleurs Graphique 132x176 type S65
  • Utilise l'interruption du Timer 2 à intervalle régulier

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é

  • un module avec afficheur couleur TFT 176x132

Acheté ici ( 35 Euros TTC seulement !) : http://www.watterott.com/en/Arduino-S65-Shield
Documentation ici : Module d'affichage à écran couleur Arduino S65 shield
Librairie pour afficheur TFT couleur S65

3.  Instructions de montage

Le module S65 Shield est à enficher directement broche à broche sur la carte Arduino réalisant ainsi les connexions suivantes : Ecran graphique S65 TFT contrôlé par 5 broches :

  • broche S65_DAT du module sur la broche 11 de la carte Arduino
  • broche S65_CLK du module sur la broche 13 de la carte Arduino
  • broche S65_RS du module sur la broche 4 de la carte Arduino
  • broche S65_RST du module sur la broche 17 de la carte Arduino
  • broche S65_CS du module sur la broche 16 de la carte Arduino


4.  Le schéma théorique du montage


Le schéma théorique du montage

5.  Le circuit du montage


Le schéma du montage à réaliser

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  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.3  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.
  • à chaque fois que l'interruption surviendra, le programme exécutera instantanément la fonction de gestion de l'interruption.

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 TFT couleur S65 :

#include <S65Display.h> // Inclusion de la librairie pour afficheur TFT couleur S65 

  • Inclusion de la librairie utilisant le Timer 2 pour l'interruption à intervalle régulier :

#include <MsTimer2.h> // inclusion de la librairie Timer2

Déclaration de constantes utiles

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

Déclaration des constantes de broches

Déclaration des variables globales

  • Déclaration des variables globales du programmes : on déclare une variable volatile pour mémoriser le comptage des secondes, des variables pour le comptage de l'heure, des minutes, ainsi que des variables utiles pour l'affichage.
volatile int seconde=0; 

int seconde0=1; // variable mémorisation seconde courante
int minute=35;
int heure=11 ;

int xo=23; // abscisse de base pour affichage heure
int yo=53; // ordonnée de base pour affichage heure

int taille=2; // taille police utilisée

int debord=5; // distance au bord du cadre en pixel

On pourra à ce niveau fixer l'heure courante au moment de la programmation de la carte Arduino, car l'heure ne sera pas réglable lors de l'exécution du programme.

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 afficheur TFT couleur S65 :

S65Display lcd; // Création d'un objet afficheur S65 appelé lcd 

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'afficheur TFT couleur S65
lcd.init(4); // initialise l'afficheur TFT couleur S65 avec communication SPI à Fosc/4 = 4 Mhz

// test de l'afficheur 
lcd.clear(RGB(255,0,0)); // efface ecran en rouge
delay (1000); // pause
lcd.clear(RGB(0,255,0)); // efface ecran en vert
delay (1000); // pause
lcd.clear(RGB(0,0,255)); // efface ecran en bleu
delay (1000); // pause

configuration des broches utilisées :

  • Initialisation de l'interruption à intervalle régulier avec le Timer 2 : on utilise un délai de 1000 ms. La fonction appelée sera InterruptTimer2.

MsTimer2::set(1000, InterruptTimer2); // période 1000ms 
MsTimer2::start(); // active Timer2 

  • On réalise également l'affichage d'un cadre autour de l'heure.

// affichage du cadre  
lcd.drawRect(xo-debord-1, yo-debord-1, xo+debord+(taille*8*8)-1, yo+debord+(taille*12)-1, jaune); 

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

  • A chaque fois que la variable seconde a été incrémentée, on assure l'affichage des variables minute, heure et seconde.

if (seconde0!=seconde) { // si incrémentation seconde a eu lieu


  //-- affichage de l'heure --
  if (heure<10)
  { // si inférieur à 10, on affiche un 0 devant
    lcd.drawInteger(xo, yo, 0, DEC, taille, jaune, bleu);
    lcd.drawInteger(xo+(taille*8*1), yo, heure, DEC, taille, jaune, bleu); 
  }
  else 
  {// sinon affiche directement la valeur
    lcd.drawInteger(xo, yo, heure, DEC, taille, jaune, bleu);
  }

  lcd.drawText(xo+(taille*8*2), yo, ":", taille, jaune, bleu); // affiche :

  //-- affichage des minutes --
  if (minute<10)  
  { // si inférieur à 10, on affiche un 0 devant
    lcd.drawInteger(xo+(taille*8*3), yo, 0, DEC, taille, jaune, bleu);
    lcd.drawInteger(xo+(taille*8*4), yo, minute, DEC, taille, jaune, bleu);
  }
  else 
  {// sinon affiche directement la valeur
    lcd.drawInteger(xo+(taille*8*3), yo, minute, DEC, taille, jaune, bleu);
  }

  lcd.drawText(xo+(taille*8*5), yo, ":", taille, jaune, bleu); // affiche :

  //-- affichage des secondes --
  if (seconde<10)
  { // si inférieur à 10, on affiche un 0 devant
    lcd.drawInteger(xo+(taille*8*6), yo, 0, DEC, taille, jaune, bleu);
    lcd.drawInteger(xo+(taille*8*7), yo, seconde, DEC, taille, jaune, bleu);
  }
  else 
  {// sinon affiche directement la valeur
    lcd.drawInteger(xo+(taille*8*6), yo, seconde, DEC, taille, jaune, bleu);
  }

  seconde0=seconde; 

} // fin if seconde0<> seconde

  • 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.  Autres Fonctions du programme :

  • Au niveau de la fonction d'interruption du Timer2, on incrémente la variable des secondes et on met à jour les autres variables des heures et minutes.

void InterruptTimer2() { // debut de la fonction d'interruption Timer2

seconde=seconde+1; // incrémentation des secondes... 

//--- gestion des variables de l'heure ---
if (seconde==60)minute=minute+1,seconde=0;
if (minute==60) heure=heure+1, minute=0;
if (heure==24) heure=0;

}

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

  • L'heure s'affiche sur l'écran.

12.  Le programme complet en langage Arduino :

A copier/coller directement dans l'éditeur Arduino


// --- Programme Arduino ---
// Copyright X. HINAULT - Créé le 25/04/2010
// www.mon-club-elec.fr 

//  Code sous licence GNU GPL : 
//  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/>.
//  

// --- Que fait ce programme ? ---
/* Comptage des secondes et affichage sur un module S65 Shield.*/

// --- Fonctionnalités utilisées ---
// Utilise un afficheur TFT 65536 couleurs Graphique 132x176 type S65
// Utilise interruption du Timer 2 à intervalle régulier

// --- Circuit à réaliser ---
// Le module S65 Shield est à enficher directement broche à broche  
// sur la carte Arduino réalisant ainsi les connexions suivantes : 
// Ecran graphique S65 TFT contrôlé par 5 broches : 
// 	> broche S65_DAT du module sur la broche 11 de la carte Arduino 
// 	> broche S65_CLK du module sur la broche 13 de la carte Arduino 
// 	> broche S65_RS du module sur la broche 4 de la carte Arduino 
// 	> broche S65_RST du module sur la broche 17 de la carte Arduino 
// 	> broche S65_CS du module sur la broche 16 de la carte Arduino 

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

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

#include <S65Display.h> // Inclusion de la librairie pour afficheur TFT couleur S65 
#include <MsTimer2.h> // inclusion de la librairie Timer2

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

// --- constantes des broches ---


// --- Déclaration des variables globales ---
volatile int seconde=0; 

int seconde0=1; // variable mémorisation seconde courante
int minute=35;
int heure=11 ;

int xo=23; // abscisse de base pour affichage heure
int yo=53; // ordonnée de base pour affichage heure

int taille=2; // taille police utilisée

int debord=5; // distance au bord du cadre en pixel

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

S65Display lcd; // Création d'un objet afficheur S65 appelé lcd 


//**************** 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.init(4); // initialise l'afficheur TFT couleur S65 avec communication SPI à Fosc/4 = 4 Mhz

// test de l'afficheur 
lcd.clear(RGB(255,0,0)); // efface ecran en rouge
delay (1000); // pause 
lcd.clear(RGB(0,255,0)); // efface ecran en vert
delay (1000); // pause 
lcd.clear(RGB(0,0,255)); // efface ecran en bleu
delay (1000); // pause 


// initialisation interruption Timer 2
  MsTimer2::set(1000, InterruptTimer2); // période 1000ms 
  MsTimer2::start(); // active Timer 2 

// affichage du cadre  
lcd.drawRect(xo-debord-1, yo-debord-1, xo+debord+(taille*8*8)-1, yo+debord+(taille*12)-1, jaune); 

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


if (seconde0!=seconde) { // si incrémentation seconde a eu lieu


  //-- affichage de l'heure --
  if (heure<10)
  { // si inférieur à 10, on affiche un 0 devant
    lcd.drawInteger(xo, yo, 0, DEC, taille, jaune, bleu);
    lcd.drawInteger(xo+(taille*8*1), yo, heure, DEC, taille, jaune, bleu); 
  }
  else 
  {// sinon affiche directement la valeur
    lcd.drawInteger(xo, yo, heure, DEC, taille, jaune, bleu);
  }

  lcd.drawText(xo+(taille*8*2), yo, ":", taille, jaune, bleu); // affiche :

  //-- affichage des minutes --
  if (minute<10)  
  { // si inférieur à 10, on affiche un 0 devant
    lcd.drawInteger(xo+(taille*8*3), yo, 0, DEC, taille, jaune, bleu);
    lcd.drawInteger(xo+(taille*8*4), yo, minute, DEC, taille, jaune, bleu);
  }
  else 
  {// sinon affiche directement la valeur
    lcd.drawInteger(xo+(taille*8*3), yo, minute, DEC, taille, jaune, bleu);
  }

  lcd.drawText(xo+(taille*8*5), yo, ":", taille, jaune, bleu); // affiche :

  //-- affichage des secondes --
  if (seconde<10)
  { // si inférieur à 10, on affiche un 0 devant
    lcd.drawInteger(xo+(taille*8*6), yo, 0, DEC, taille, jaune, bleu);
    lcd.drawInteger(xo+(taille*8*7), yo, seconde, DEC, taille, jaune, bleu);
  }
  else 
  {// sinon affiche directement la valeur
    lcd.drawInteger(xo+(taille*8*6), yo, seconde, DEC, taille, jaune, bleu);
  }

  seconde0=seconde; 

} // fin if seconde0<> seconde


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

//*************** Autres Fonctions du programme *************

void InterruptTimer2() { // debut de la fonction d'interruption Timer2

seconde=seconde+1; // incrémentation des secondes... 

//--- gestion des variables de l'heure ---
if (seconde==60)minute=minute+1,seconde=0;
if (minute==60) heure=heure+1, minute=0;
if (heure==24) heure=0;

}
// --- Fin programme ---