Le test d’affichage de texte sur un afficheur couleur TFT 176×132 type S65 est une tâche importante pour les concepteurs et les développeurs de produits électroniques. Il est essentiel de s’assurer que le texte affiché sur l’écran est clair et lisible, et que les couleurs sont précises et cohérentes. Ce test peut être effectué en utilisant des outils spécialisés et des méthodes spécifiques. Dans cet article, nous allons examiner en détail les différentes étapes et les outils nécessaires pour effectuer un test d’affichage de texte sur un afficheur couleur TFT 176×132 type S65.
Test d’affichage de texte sur un afficheur couleur TFT 176×132 type S65
Présentation
Ce programme affiche des demi-cercles colorés sur un afficheur TFT couleur 176×132 type S65. Ce programme montre la rapidité de calcul de l’Arduino qui utilise ici les fonctions sinus et cosinus. Ce type d’affichage pourra servir de base pour des applications type « radar » ou jauge analogique. Et ce programme ne fait que 5Ko… Vive Arduino !
Ce programme utilise les fonctionnalités suivantes :
- Utilise un afficheur TFT 65536 couleurs Graphique 132×176 type S65
Voir également :
La librairie est à copier coller dans votre répertoire librairie de votre répertoire Arduino.
Matériel Nécessaire
L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.
Le matériel suivant pour réaliser le montage associé
- un module avec afficheur couleur TFT 176×132
Acheté ici ( 35 Euros TTC seulement !) : http://www.watterott.com/en/Arduino-S65-Shield
Documentation ici : http://www.watterott.net/projects/s65-shield
La librairie Arduino ici : http://www.watterott.net/arduino/s65-shield_v013.zip
Instructions de montage
L’utilisation de ce module est très simple : le module S65 Shield est à enficher directement broche à broche sur la carte Arduino
Ceci réalise les connexions suivantes en ce qui concerne l’afficheur :
- 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
- Broche Analog 0 (=broche 14) en entrée Analogique
- Broche Analog 4 (=broche 18) en entrée Analogique
- Broche Analog 5 (=broche 19) en entrée Analogique
Le schéma théorique du montage
Le schéma théorique du montage
Le circuit du montage
Le montage consiste à :
- enficher directement le module Arduino S65 shield sur la carte Arduino qui correspond broche à broche
- à connecter 3 Résistances variables comme indiqué. Pour laisser libre les broches analogiques corespondantes, plier les pattes correspondante sous le module avant de l’enficher.
Le schéma du montage à réaliser
Explication du programme
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.
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
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
Déclaration de constantes utiles
- On déclare les constantes utiles dans le programme :
Déclaration des variables globales
- Déclaration des variables globales du programmes :
// --- Déclaration des variables globales --- float anglef=0.0; // variable angle tracé rayon courant float rayonf=80.0; // rayon du cercle int xo=87; // abscisse point référence int yo=20; // ordonnée point référence float xf=0.0; // abscisse point calculé à virgule float yf=0.0; // ordonnée point calculé à virgule int x=0; // abscisse point calculé int y=0; // ordonnée point calculé int couleur=0; // variable couleur tracé
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
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 (500); // pause lcd.clear(RGB(0,255,0)); // efface ecran en vert delay (500); // pause lcd.clear(RGB(0,0,255)); // efface ecran en bleu delay (500); // pause lcd.clear(noir); // efface ecran en noir
configuration des broches utilisées :
Au niveau de la boucle principale, la fonction loop ( ) :
- Au sein d’une boucle principale, on répéte 4 fois l’affichage du demi-cercle coloré, en sélectionnant la couleur voulue.
for (int j=1; j<=4; j++) { // répéte le tracé 4 fois
// -- choix couleur du tracé --
if (j==1) couleur=vert;
if (j==2) couleur=bleu;
if (j==3) couleur=jaune;
if (j==4) couleur=rouge;
- La boucle du tracé du demi-cercle coloré utilise le principe de défilement des degrés de 0 à 180 et trace le rayon correspondant à chaque angle. Pour chaque rayon, on trace une ligne entre le point de référence xo,yo, centre de la base du demi-cercle et on calcule les coordonnées du point x,y sur le cercle correspondant à l’angle, à l’aide des fonctions mathématiques sinus et cosinus. Au préalable on convertit l’angle en radians.
Ceux qui ne comprendrait pas les math utilisés ici peuvent aller faire un tour ici pour réviser quelques notions de base :
http://fr.wikipedia.org/wiki/Cercle
// trace demi-cercle de la couleur voulue
for (int i=0; i<=180; i++) // boucle de défilement des degrés de 0 à 180
{
// calcul de l'angle en radians
anglef = float(i);
anglef=anglef*3.14159;
anglef=anglef/180.0;
//--- calcul x
xf= cos(anglef);
xf=rayonf*xf;
x=int(xf);
//--- calcul y
yf= sin(anglef);
yf=rayonf*yf;
y=int(yf);
lcd.drawLine(xo,131-yo, xo+x, 131-yo-y, couleur); // trace la ligne du rayon pour angle courant
} // fin for angle
Se reporter aux commentaires présents dans le programme pour plus de détails.
Mise en oeuvre du programme
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
Fonctionnement
- Les demi-cercles colorés se succèdent alternativement… joli non ? Et au passage, ce petit programme nous montre toute la puissance de l’Arduino… le programme ne faisant que 5ko !
Le programme complet en langage Arduino :
A copier/coller directement dans l’éditeur Arduino
// --- Programme Arduino ---
// Copyright X. HINAULT - Créé le 01/05/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 ? ---
/* Affiche un demi-cercle plein sur afficheur couleur S65 shield*/
// --- Fonctionnalités utilisées ---
// Utilise un afficheur TFT 65536 couleurs Graphique 132x176 type S65
// --- 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
// --- Déclaration des constantes ---
// --- constantes des broches ---
// --- Déclaration des variables globales ---
float anglef=0.0; // variable angle tracé rayon courant
float rayonf=80.0; // rayon du cercle
int xo=87; // abscisse point référence
int yo=20; // ordonnée point référence
float xf=0.0; // abscisse point calculé à virgule
float yf=0.0; // ordonnée point calculé à virgule
int x=0; // abscisse point calculé
int y=0; // ordonnée point calculé
int couleur=0; // variable couleur tracé
// --- 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 (500); // pause
lcd.clear(RGB(0,255,0)); // efface ecran en vert
delay (500); // pause
lcd.clear(RGB(0,0,255)); // efface ecran en bleu
delay (500); // pause
lcd.clear(noir); // efface ecran en noir
} // 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 (int j=1; j<=4; j++) { // répéte le tracé 4 fois
// -- choix couleur du tracé --
if (j==1) couleur=vert;
if (j==2) couleur=bleu;
if (j==3) couleur=jaune;
if (j==4) couleur=rouge;
// trace demi-cercle de la couleur voulue
for (int i=0; i<=180; i++) // boucle de défilement des degrés de 0 à 180
{
// calcul de l'angle en radians
anglef = float(i);
anglef=anglef*3.14159;
anglef=anglef/180.0;
//--- calcul x
xf= cos(anglef);
xf=rayonf*xf;
x=int(xf);
//--- calcul y
yf= sin(anglef);
yf=rayonf*yf;
y=int(yf);
lcd.drawLine(xo,131-yo, xo+x, 131-yo-y, couleur); // trace la ligne du rayon pour angle courant
} // fin for angle
} // fin for répétition tracé
// --- ici instructions à exécuter par le programme principal ---
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
//*************** Autres Fonctions du programme *************
// --- Fin programme ---
