L’arc-en-ciel est un phénomène naturel qui fascine depuis des siècles. Il est maintenant possible de le voir sur un afficheur couleur TFT 320×240. Grâce à cette technologie, vous pouvez admirer les couleurs vives et les nuances subtiles de l’arc-en-ciel, sans avoir à sortir de chez vous. Dans cet article, nous allons vous expliquer comment profiter de cette technologie pour voir un arc-en-ciel sur un afficheur couleur TFT 320×240.
Arc-en-ciel sur afficheur couleur TFT 320×240
(cliquer sur l’image pour agrandir)
1. Présentation
Affiche un dégradé de couleurs sur un afficheur TFT 240 x320
Ce programme utilise les fonctionnalités suivantes :
- Utilise adaptateur pour écran MI0283QT2 240×320 pixels – 262 K couleurs
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 adaptateur pour afficheur MI0283QT-2 de chez Watterott

- Watterrott propose également un circuit imprimé de compatibilité pour la carte Arduino à coupler avec cet adaptateur d’écran , le mSD-shield (15 Euros) : http://www.watterott.com/de/Arduino-mSD-Shield L’utilisation est alors très simple puisqu’il suffit d’enficher le module sur la carte Arduino.

3. Instructions de montage
- Connexions à réaliser pour adaptateur écran MI0283QT2 240×320 pixels – 262 K couleurs
Note : ces connexions sont réalisées automatiquement si utilisation du circuit imprimé mSD-shield
-
- Broches utilisées pour le contrôle de l’afficheur graphique
- broche CS de l’adaptateur sur la broche 7
- broche RST de l’adaptateur sur la broche 8
- broche LED de l’adaptateur sur la broche 9
- broches utilisées pour la communication SPI de l’adaptateur MI0283QT2
- broche SDI de l’adaptateur sur la broche 11
- broche SDO de l’adaptateur sur la broche 12
- broche SCL de l’adaptateur sur la broche 13
- Broches utilisées pour le contrôle de l’afficheur graphique
4. Le circuit du montage
5. Fonctionnement du programme
5.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.
5.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
6. Explication du programme
- Voir les commentaires du programme pour les détails
7. Mise en oeuvre du programme
7.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
7.2 Fonctionnement
8. Le programme complet en langage Arduino
A copier/coller directement dans l’éditeur Arduino
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr
// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 27/10/2010.
// ——- 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 ? ———
/* Affiche un dégradé de couleurs sur un afficheur TFT 240 x320 */
// — Fonctionnalités utilisées —
// Utilise adaptateur pour écran MI0283QT2 240×320 pixels – 262 K couleurs
// ——– Circuit à réaliser ———
// Connexions à réaliser pour adaptateur écran MI0283QT2 240×320 pixels – 262 K couleurs
// ces connexions sont réalisées automatiquement si utilisation du circuit imprimé mSD-shield
// —– broches utilisées pour le contrôle de l’afficheur graphique
// broche CS de l’adaptateur sur la broche 7
// broche RST de l’adaptateur sur la broche 8
// broche LED de l’adaptateur sur la broche 9
// —– broches utilisées pour la communication SPI de l’adaptateur MI0283QT2
// broche SDI de l’adaptateur sur la broche 11
// broche SDO de l’adaptateur sur la broche 12
// broche SCL de l’adaptateur sur la broche 13
// /////////////////////////////// 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 <MI0283QT2.h> // librairie de l’afficheur TFT MI0283QT2
// Avant utilisation, il faut installer manuellement cette librairie
// dans le dossier <Libraries> du dossier Arduino
// — Déclaration des constantes utiles —
// — Déclaration des constantes des broches E/S numériques —
// — Déclaration des constantes des broches analogiques —
// — Déclaration des variables globales —
int couleur=0; // variable utilisée pour la couleur
int section1=0,section2=0,section3=0; // variable pour partage écran
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
MI0283QT2 lcd; // création d’un objet de type MI0283QT2 appelé lcd
// ////////////////////////// 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 écran MI0283QT2 240×320 pixels
lcd.init(4); //spi-clk = Fcpu/4
lcd.clear(RGB(255,255,255)); // efface ecran en blanc
//configuration écran MI0283QT2 240×320 pixels – après calibrage touchpad
lcd.setOrientation(270); // configure orientation afficheur en degrés : 0,90,180,270
// Par défaut 0 = point 0,0 en regard connecteur USB
lcd.clear(RGB(255,255,255)); // efface ecran en blanc
lcd.led(50); // fixe luminosité
// ——- 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 —
//—– pixel central —–
int xo=lcd.getWidth()/2;
int yo=lcd.getHeight()/2;
lcd.drawPixel(xo, yo, RGB(0,0,255));
//—— 1er dégradé —-
section1=(lcd.getHeight()/3);
for (int y=0; y<=section1; y++) { // défilement des y de haut en bas
couleur=map(y,0,section1,0,255); // rééchelonne y sur échelle de couleur 0-255
lcd.drawLine (0,y,lcd.getWidth()–1,y,RGB(couleur,0,0));
}
section2=2*(lcd.getHeight()/3);
for (int y=section1; y<=section2; y++) { // défilement des y de haut en bas
couleur=map(y,section1,section2,0,255); // rééchelonne y sur échelle de couleur 0-255
lcd.drawLine (0,y,lcd.getWidth()–1,y,RGB(0,couleur,0));
}
section3=3*(lcd.getHeight()/3);
for (int y=section2; y<=section3+1; y++) { // défilement des y de haut en bas
couleur=map(y,section2,section3,0,255); // rééchelonne y sur échelle de couleur 0-255
lcd.drawLine (0,y,lcd.getWidth()–1,y,RGB(0,0,couleur));
}
delay (2000);
//—— 2ème dégradé —-
section1=(lcd.getHeight()/3);
for (int y=0; y<=section1; y++) { // défilement des y de haut en bas
couleur=map(y,0,section1,0,255); // rééchelonne y sur échelle de couleur 0-255
lcd.drawLine (0,y,lcd.getWidth()–1,y,RGB(couleur,255–couleur,0));
}
section2=2*(lcd.getHeight()/3);
for (int y=section1; y<=section2; y++) { // défilement des y de haut en bas
couleur=map(y,section1,section2,0,255); // rééchelonne y sur échelle de couleur 0-255
lcd.drawLine (0,y,lcd.getWidth()–1,y,RGB(255–couleur,0,couleur));
}
section3=3*(lcd.getHeight()/3)+1;
for (int y=section2; y<=section3; y++) { // défilement des y de haut en bas
couleur=map(y,section2,section3,0,255); // rééchelonne y sur échelle de couleur 0-255
lcd.drawLine (0,y,lcd.getWidth()–1,y,RGB(0,couleur,255–couleur));
}
delay(2000);
//—— 3ème dégradé —-
section1=(lcd.getHeight()/3);
for (int y=0; y<=section1; y++) { // défilement des y de haut en bas
couleur=map(y,0,section1,0,255); // rééchelonne y sur échelle de couleur 0-255
lcd.drawLine (0,y,lcd.getWidth()–1,y,RGB(0,couleur,couleur));
}
section2=2*(lcd.getHeight()/3);
for (int y=section1; y<=section2; y++) { // défilement des y de haut en bas
couleur=map(y,section1,section2,0,255); // rééchelonne y sur échelle de couleur 0-255
lcd.drawLine (0,y,lcd.getWidth()–1,y,RGB(couleur,255,255–couleur));
}
section3=3*(lcd.getHeight()/3)+1;
for (int y=section2; y<=section3; y++) { // défilement des y de haut en bas
couleur=map(y,section2,section3,0,255); // rééchelonne y sur échelle de couleur 0-255
lcd.drawLine (0,y,lcd.getWidth()–1,y,RGB(255–couleur,255–couleur,0));
}
delay(2000);
// while(1); // stop loop
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
Articles similaires:
- Mini-oscilloscope à écran couleur TFT 320×240 mono-voie
- Trotteuse à points sur afficheur couleur TFT 320×240
- Analyseur logique 4 voies à affichage graphique sur écran couleur 320×240
- http://web.archive.org/web/20210804223007/http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.MaterielAffichageAdaptateurMI0283QT-2
- Titre
Articles Liés
- Trotteuse à points sur afficheur couleur TFT 320x240
La technologie évolue à un rythme effréné et les fabricants de montres s'efforcent de suivre…
- ARDUINO : EXPERT : Afficheur Graphique Couleur TFT 240x320 pixels
L'Arduino est une plateforme de prototypage électronique open-source qui permet aux développeurs de créer des…
- ARDUINO : EXPERT : Afficheur Graphique TFT 65536 couleurs 176x132 pixels
L'Arduino est une plateforme de prototypage électronique open-source qui permet aux développeurs de créer des…