Constantes couleurs

Je conseille très fortement d'utiliser les noms de couleur. Il n'y a pas du tout de linéarité entre la valeur des composantes couleur et le rendu. On est obligé d'utiliser une couleur dans les fonctions de dessins et pour écrire un texte. Sinon, c'est la couleur par défaut qui est utilisée (blanc au départ).

Les constantes définies sont:

 

Exemples d'utilisation

point(x, y, DEEP_PINK); // Trace un point rose
point(x, y, LIGHT_MAGENTA); // Trace un point magenta clair, violet pâle
setTextColor(GREEN); // Nnous indique que les prochaines écritures se feront en vert.
clrscr(DARK_BLUE); // Remplit l'écran de bleu foncé. Cela efface l'écran en quelque sorte.

 

Référence

// Couleurs grises
#define BLACK         0x0000 // 0,0,0
#define DARK_GREY     0x7BEF // 15,31,15
#define GREY          0xD6FA // 26,55,26
#define LIGHT_GREY    0xF7DE // 31,63,31
#define WHITE         0xFFFF // 31,63,31

// Les 6 couleurs primaires
#define RED           0xF800 // 31,0,0
#define GREEN         0x07E0 // 0,63,0
#define BLUE          0x001F // 0,0,31
#define CYAN          0x07FF // 0,63,31
#define MAGENTA       0xF81F // 31,0,31
#define YELLOW        0xFFE0 // 31,63,0

// Les 6 couleurs primaires plus claires
#define LIGHT_RED     0xFFBE // 31,61,30
#define LIGHT_GREEN   0xF7FE // 30,63,30
#define LIGHT_BLUE    0xF7BF // 30,61,31
#define LIGHT_CYAN    0xF7FF // 30,63,31
#define LIGHT_MAGENTA 0xFFBF // 31,61,31
#define LIGHT_YELLOW  0xFFFE // 31,63,30

// Les 6 couleurs primaires plus foncé
#define DARK_RED      0xC800 // 25,0,0
#define DARK_GREEN    0x0600 // 0,48,0
#define DARK_BLUE     0x0018 // 0,0,24
#define DARK_CYAN     0x0618 // 0,48,24
#define DARK_MAGENTA  0xC818 // 25,0,24

// Couleurs diverses
#define BISQUE        0xF79C // 30,60,28
#define LIME          0xF7E0 // 30,63,0
#define MAROON        0xD000  // 26,0,0
#define OLIVE         0xD5E0 // 26,47,0
#define ORANGE        0xFF20 // 31,57,0
#define DEEP_PINK     0xF81D // 31,0,29
#define ROYAL_BLUE    0xE81F // 29,0,31
#define SEA_GREEN     0x9720 // 18,57,0
#define STEEL_BLUE    0x73D // 0,57,29

 

Voir aussi

- RGBcolor(); Transforme un triplet RGB en un code couleur
- getColor(); Retourne la couleur par défaut pour les dessins
- MAX_RED...: Valeur maximum d'une composante couleur
- BLACK, WHITE, ...: Constantes couleurs
- setDrawInverse(); Choix du mode dessin ou inversion
- point(); Dessine un point
- line(); Trace une ligne
- rect(); Trace les bords d'un cadre
- fillRect(); Trace une boîte pleine
- arc(); Trace des arcs de cercle
- circle(); Trace un cercle
- fill(); Remplit avec la couleur demandée
- text(); Écrit du texte

 

Exemple

PecheuxGraph_ILI9341_8bits.zip\PecheuxGraph_ILI9341_8bits\examples\Documentation\Exemple-110-BLACK.ino (dans votre fichier téléchargé):

// Ce programme affiche la palette des couleurs prédéfinies.
// Chaque ligne affiche une couleur dans un pavé, et y met le nom.
// Le nom est écrit en le plus petit possible, mais certains noms
// doivent s'écrire en trois fois. Avant d'écrire, il faut
// positionner le curseur texte.
// En général pour le nom de la couleur, on utilise la couleur
// opposée (opposé de BLACK => ~BLACK). Cela fonctionne très
// bien pour les couleurs éloignées du gris moyen. En effet 
// l'opposé du rouge donne le cyan... mais l'opposé du WHITE/2,
// c'est le WHITE/2. Pour ces cas, j'utilise le blanc ou le noir
// Il eut été mieux de faire un boucle, mais cela aurait été
// moins compréhensible

#include <PecheuxGraph_ILI9341_8bits.h>

void setup() 
{
  setGraphMode(PAYSAGE); // Indispensable pour utiliser l'afficheur
  int x0=0, 
      x1=LARGEUR/5, // LARGEUR n'est défini qu'après setGraphMode!
	  x2=2*LARGEUR/5,
	  x3=3*LARGEUR/5,
	  x4=4*LARGEUR/5,
	  x5=LARGEUR;
  int y0=0,
      y1=HAUTEUR/6,
      y2=2*HAUTEUR/6,
      y3=3*HAUTEUR/6,
	  y4=4*HAUTEUR/6,
	  y5=5*HAUTEUR/6,
	  y6=HAUTEUR,
	  dy=y1/2-10;
  setTextSize(1); // Pour nommer les couleurs, les cases sont petites
  
  fillRect(x0,y0,x1,y1,BLACK);
    setTextColor(~BLACK);
	setTextCursor(x0+2,y0+dy);
	text("BLACK");
  fillRect(x1,y0,x2,y1,DARK_GREY);
    setTextColor(WHITE);
	setTextCursor(x1+2,y0+dy);
	text("DARK_");
	setTextCursor(x1+6,y0+dy+9);
	text("GREY");
  fillRect(x2,y0,x3,y1,GREY);
    setTextColor(WHITE);
	setTextCursor(x2+2,y0+dy);
	text("GREY");
  fillRect(x3,y0,x4,y1,LIGHT_GREY);
    setTextColor(WHITE);
	setTextCursor(x3+2,y0+dy);
	text("LIGHT_");
	setTextCursor(x3+6,y0+dy+9);
	text("GREY");
  fillRect(x4,y0,x5,y1,WHITE);
    setTextColor(~WHITE);
	setTextCursor(x4+2,y0+dy);
	text("WHITE");
  
  fillRect(x0,y1,x1,y2,RED);
    setTextColor(~RED);
	setTextCursor(x0+2,y1+dy);
	text("RED");
  fillRect(x1,y1,x2,y2,GREEN);
    setTextColor(~GREEN);
	setTextCursor(x1+2,y1+dy);
	text("GREEN");
  fillRect(x2,y1,x3,y2,BLUE);
    setTextColor(~BLUE);
	setTextCursor(x2+2,y1+dy);
	text("BLUE");
  fillRect(x3,y1,x4,y2,CYAN);
    setTextColor(~CYAN);
	setTextCursor(x3+2,y1+dy);
	text("CYAN");
  fillRect(x4,y1,x5,y2,MAGENTA);
    setTextColor(~MAGENTA);
	setTextCursor(x4+2,y1+dy);
	text("MAGE");
	setTextCursor(x4+6,y1+dy+9);
	text("NTA");
  
  fillRect(x0,y2,x1,y3,YELLOW);
    setTextColor(~YELLOW);
	setTextCursor(x0+2,y2+dy);
	text("YELLOW");
  fillRect(x1,y2,x2,y3,LIGHT_RED);
    setTextColor(~LIGHT_RED);
	setTextCursor(x1+2,y2+dy);
	text("LIGHT_");
	setTextCursor(x1+6,y2+dy+9);
	text("RED");
  fillRect(x2,y2,x3,y3,LIGHT_BLUE);
    setTextColor(~LIGHT_BLUE);
    setTextCursor(x2+2,y2+dy);
	text("LIGHT_");
	setTextCursor(x2+6,y2+dy+9);
	text("BLUE");
  fillRect(x3,y2,x4,y3,LIGHT_CYAN);
    setTextColor(~LIGHT_CYAN);
    setTextCursor(x3+2,y2+dy);
	text("LIGHT_");
	setTextCursor(x3+6,y2+dy+9);
	text("CYAN");
  fillRect(x4,y2,x5,y3,LIGHT_MAGENTA);
    setTextColor(~LIGHT_MAGENTA);
	setTextCursor(x4+2,y2+dy);
	text("LIGHT_");
	setTextCursor(x4+6,y2+dy+9);
	text("MAGE");
	setTextCursor(x4+6,y2+dy+18);
	text("NTA");
  
  fillRect(x0,y3,x1,y4,LIGHT_YELLOW);
    setTextColor(~LIGHT_YELLOW);
	setTextCursor(x0+2,y3+dy);
	text("LIGHT_");
	setTextCursor(x0+6,y3+dy+9);
	text("YELLOW");
  fillRect(x1,y3,x2,y4,DARK_RED); 
    setTextColor(~DARK_RED);
	setTextCursor(x1+2,y3+dy);
	text("DARK_");
	setTextCursor(x1+6,y3+dy+9);
	text("RED");
  fillRect(x2,y3,x3,y4,DARK_GREEN);
    setTextColor(~DARK_GREEN);
    setTextCursor(x2+2,y3+dy);
	text("DARK_");
	setTextCursor(x2+6,y3+dy+9);
	text("GREEN");
  fillRect(x3,y3,x4,y4,DARK_BLUE);
    setTextColor(~DARK_BLUE);
	setTextCursor(x3+2,y3+dy);
	text("DARK_");
	setTextCursor(x3+6,y3+dy+9);
	text("BLUE");
  fillRect(x4,y3,x5,y4,DARK_CYAN);
    setTextColor(~DARK_CYAN);
	setTextCursor(x4+2,y3+dy);
	text("DARK_");
	setTextCursor(x4+6,y3+dy+9);
	text("CYAN");
  
  fillRect(x0,y4,x1,y5,DARK_MAGENTA);
    setTextColor(~DARK_MAGENTA);
	setTextCursor(x0+2,y4+dy); text("DARK_");
	setTextCursor(x0+6,y4+dy+9);
	text("MAGE");
	setTextCursor(x0+6,y4+dy+18);
	text("NTA");
  fillRect(x1,y4,x2,y5,STEEL_BLUE);
    setTextColor(~STEEL_BLUE);
    setTextCursor(x1+2,y4+dy); text("STEEL_");
	setTextCursor(x1+6,y4+dy+9);
	text("BLUE");
  fillRect(x2,y4,x3,y5,OLIVE);
    setTextColor(WHITE);
	setTextCursor(x2+2,y4+dy);
	text("OLIVE");
  fillRect(x3,y4,x4,y5,ROYAL_BLUE);
    setTextColor(~ROYAL_BLUE);
    setTextCursor(x3+2,y4+dy);
	text("ROYAL_");
	setTextCursor(x3+6,y4+dy+9);
	text("BLUE");
  fillRect(x4,y4,x5,y5,ORANGE);
    setTextColor(~ORANGE);
	setTextCursor(x4+2,y4+dy);
	text("ORANGE");
  
  fillRect(x0,y5,x1,y6,MAROON);
    setTextColor(~MAROON);
	setTextCursor(x0+2,y5+dy);
	text("MAROON");
  fillRect(x1,y5,x2,y6,BISQUE);
    setTextColor(~BISQUE);
	setTextCursor(x1+2,y5+dy);
	text("BISQUE");
  fillRect(x2,y5,x3,y6,SEA_GREEN);
    setTextColor(WHITE);
	setTextCursor(x2+2,y5+dy);
	text("SEA_");
    setTextCursor(x2+6,y5+dy+9);
	text("GREEN");
  fillRect(x3,y5,x4,y6,DEEP_PINK);
    setTextColor(~DEEP_PINK);
    setTextCursor(x3+2,y5+dy);
	text("DEEP_");
	setTextCursor(x3+6,y5+dy+9);
	text("PINK");
  fillRect(x4,y5,x5,y6,LIME);
    setTextColor(~LIME);
	setTextCursor(x4+2,y5+dy);
	text("LIME");
}

void loop()
{
}

Résultat:

 

Côté technique

La valeur numérique d'une couleur n'est pas proportionnelle à la luminosité de l'écran. C'est pour cela que les constantes sont intéressantes. En fait les couleurs changent beaucoup quand les valeurs varient autour du maximum et très peu après. En reprenant les valeurs de 3 couleurs:
BLACK peut aussi s'écrire RGBcolor(0,0,0); les 3 composantes sont nulles
WHITE peut aussi s'écrire RGBcolor(31,63,31); les trois composantes sont au maximum
la couleur définie par RGBcolor(30,62,30); est extrêmement proche du blanc pour ses valeurs. C'est le gris le plus clair que l'on peut avoir. Et pourtant il est déjà foncé! Je l'ai appelé LIGHT_GREY, et il n'est pas possible d'obtenir un gris plus pâle.

Attention aussi quand on passe des dessins entre un ordinateur et un écran TFT, une couleur très pâle de l'ordinateur se traduit par une couleur bien marquée, et donc fortement différente. L'image de l'exemple ci-dessus n'est pas une copie d'écran, elle a été recolorée pour avoir un rendu similaire de ce qui est vu sur l'écran. Ci dessous la vraie copie d'écran.

 

initSD()   <<     >>   MAX_RED