text()

Écrit du texte

 

Exemples d'utilisation

text("Bonjour"); // Écrit le mot Bonjour
text(F("Bonjour")); // Pareil, mais économise l'espace de données
String s="Bonjour"; text(s); // Écrit le mot Bonjour
text(F("Bonjour\nAu revoir")); // Écrit le mot Bonjour sur une ligne et Au revoir sur la ligne d'après
text(F("\n\n\nRetour chariot ---> \\n\n")); // va à la ligne 3 fois (\n), affiche "Retour chariot ---> ",
       // affiche \n car il y a deux caractères \, puis va à la ligne (encore un \n).
text("\a"); // N'écrit rien, le caractère \a n'est pas pris en charge
char lettre='c'; text(lettre); // Erreur de compilation car "lettre" n'est pas une chaîne "String"
char lettre='c'; text(String(lettre)); // Affiche correctement le caractère c
int n=53; text(n); // Erreur de compilation car "n" n'est pas une chaîne "String"
int n=53; text(String(n)); // Affiche 53
int n=53; text("J'ai payé "+String(n)+"?\t(c'est cher!)"); // Affiche: J'ai payé 53?   (c'est cher!)

 

Référence

void text(String phrase);

Paramètre passé

phrase: texte à écrire

Valeur retournée

Aucune

 

Voir aussi

- Fonte vectorielle Définition de la fonte utilisée
- setGraphMode(); Initialisation de l'écran
- clrscr(); Efface l'écran
- setLimites(); Limite la zone de dessin
- setTextColor(); Couleur du texte
- setTextSize(); Taille des caractères
- setTextBold(); Gras ou normal
- setTextItalic(); Italique ou normal
- setTextSerif(); Avec ou sans empattement
- setTextOrient(); Direction d'écriture des textes
- setTextCursor(); Coordonnés le point-curseur
- setTextKeep(); Choisit l'action si le texte déborde
- getTextWidth(); Retourne la largeur de l'écriture de la chaîne passée
- getTextHeight(); Retourne la hauteur de l'écriture de la chaîne passée
- point(); Dessine un point
- line(); Trace une ligne
- circle(); Trace un cercle

 

Notes

Écrit une chaîne de caractère. Les caractères affichables sont :
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
a b c d e f g h i j k l m n o p q r s t u v w x y z
à á â ç è é ê ë î ï ° ± ò ó ô µ ö ÷ ù ú û ü €
0 1 2 3 4 5 6 7 8 9
! " # $ % & ' ( ) * + , - . / : ; < = > ; ? @ [ \ ] _ { | } ~

ainsi que le retour chariot se codant \n et le tabulateur \t. Pour afficher le caractère \, il faut mettre \\ .

Les caractères sont codés avec la norme UTF-8. Ceux qui correspondent au code ASCII (7 bits) occupent 1 octet. D'autres, comme les lettres accentuées, sont codés sur deux octets. Toutefois, c'est assez transparent pour l'utilisateur qui va taper un texte au clavier avec l'IDE d'Arduino. Le caractère est décodé, puis affiché correctement. Il peut être gênant que la longueur d'une chaîne de caractères peut être supérieure au nombre de caractères. Mais c'est pareil pour le type String.

La couleur des caractères se change par setTextColor(). La couleur du fond n'est pas modifiable, elle est transparente; pour changer la couleur du fond, on peut dessiner le fond grâce à fillRect()) avant et un caractère dessus. La taille se choisit par setTextSize(). les caractères peuvent être de filiformes à extrêmement gras grâce à setTextBold(), L'empattement possible ou non par setTextSerif(). Et on peut écrire en italique ou droit avec la fonction setTextItalic(). On peut écrire dans les 4 directions en faisant appel à setTextOrient(). Le curseur texte est le point le plus en haut à gauche du prochain caractère écrit. On peut en changer sa place grâce à setTextCursor().

Après initialisation de l'afficheur et de sa librairie, les caractères sont blancs sur fond transparent, de taille 2, filiformes, avec empattements, droits, le point curseur est tout en haut à gauche, et l'écriture se fait vers la droite.

Si un caractère doit être écrit et que de sa position, il dépasserait de l'écran ou des limites imposées par la fonction setLimites(), l'action déclenchée dépend du choix fait par la fonction setTextKeep(). Par défaut, on tourne la page (écran effacé, curseur texte en haut à gauche). Mais on peut choisir le mode KEEP (on n'efface pas l'écran) ou le mode CUT (ce qui dépasse est ignoré).

La couleur du fond est transparente, les caractères peuvent se sur-imprimer les uns sur les autres.

La tabulation est fixe et un tabulateur vaut 20 pixels. Cela veut dire qu'après un tabulateur, l'abscisse du curseur texte vaut 20, 40, 60, ...

text() attend une String. En conséquence, on peut utiliser la puissance de C pour définir le paramètre:
- On peut utiliser la concaténation des chaînes -> String s1, s2; text(s1 + s2);
- On peut afficher un caractère, mais il faut le changer en chaîne -> char c; text(String(c));
- On peut afficher un entier ou un long, mais il faut le changer en chaîne -> int x; text(String(x));
- On peut afficher un entier court (=char), mais char c; text(String(c)); affiche le caractère, pas le nombre. Il suffit de transformer le char en entier quelconque sauf char, puis de repasser en chaîne -> char c; text(String((byte)c));
- On peut afficher le numéro du caractère -> char c; text(String(byte(c)));

Notez qu'il existe une macro pour passer les chaînes en mémoire programme:
text("Cette phrase est dans les données");
text(F("Cette phrase dans l'espace programme"));

Cela libère de l'espace pour les données et pour la pile...

 

Exemple

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

// Ce programme affiche en taille 2 tous les caractères imprimables, le retour chariot et le tabulateur.
// Pour ce dernier, est affiché 3 lignes de 3 caractères, comme une grille de morpion.

#include <PecheuxGraph_ILI9341_8bits.h>
void setup() 
{
  setGraphMode(PAYSAGE); // Initialisation générale
  
  for (char c=33; c<127; c++) text(String(c)); // Affiche les premiers caractères qui tiennent sur un seul octet
  text(F("àáâçèéêëîï°±òóôµö÷ùúûü?")); // Ceux-ci ne correspondent pas au code ascii, mais sont imprimables
  text(F("\n\nRetour chariot ---> \\n\n")); // Le retour chariot, c'est \n. Pour écrire \ il faut en mettre 2!
  text(F("Tabulateur ---> \\t\n\n")); // Le tabulateur, c'est \t.
  text(F("O\\tX\\tX\\nX\\tO\\tO\\nX\\tO\\tO:\n")); // Grille de morpion, pour explications
  text(F("O\tX\tX\nX\tO\tO\nX\tO\tO")); // Grille de morpion, pour dessin
}

void loop()
{
}

Résultat:

 

Côté technique

Taille et dépassements

Quand un caractère doit être écrit, on regarde si il tient. Si il est trop large pour tenir dans la largeur compte tenu de l'abscisse du curseur texte, un retour chariot est effectué avant. Si il ne tient pas verticalement en tenant compte de l'ordonnée du curseur texte, le curseur texte est remis en haut de l'écran, soit en appelant clrscr() si on est en mode normal, soit sans effacer l'écran si on a appelé setTextKeep(KEEP); . Ceci a plusieurs conséquences:
- c'est fait pour chaque caractère, il est donc possible que des mots soient coupés. Il n'y a pas de césure.
- si on va au début de l'écran, si il n'y a pas d'effacement de celui-ci, et les caractères s'inscrivent les uns sur les autres
- si le caractère est trop grand pour tenir seul à l'écran, le curseur texte reviendra à l'origine une seule fois et le caractère sera dessiné, du moins ce qui ne dépasse pas.

Codes ascii ou pas...

Les codes des lettres, des chiffres et des symboles !"#$%&'()*+,-./:;<=>?@[\]_{|}~ correspondent au code ascii. Ainsi si chaine="ABC", chaine[1] contient 0x41 ou 65. C'est normal. La chaîne "ABC" contient 3 caractères.

Les symboles àáâçèéêëîï°±òóôµö÷ùúûü€ sont codés suivant la norme UTF8. Si on écrit chaine="L'été", chaine ne contient pas 5 caractères, mais 7 car le "é" se code avec les 2 valeurs 195 et 169. Le code 169 correspond en principe au code ascii du 'é'. Tous les symboles ci-dessus sont codés avec 2 octets, le premier étant 194 ou 195, le deuxième étant en principe le code ascii étendu du caractère. Exception: le '€' qui est codé sur 3 octets 226 130 et 172. Dans la plupart des cas le système Arduino et PC sont compatibles.

Fonte de caractères

La fonte est vectorielle, et les caractères sont constitués de segments de droites et d'arcs de cercle. Cette fonte est définie afin de minimaliser la taille, et c'est pour cela que certains caractères sont "mal dessinés". Par contre elle supporte bien les agrandissements. La largeur des caractères est variable. Voir comment est définie la fonte vectorielle

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

// Ce programme écrit SUR LA CONSOLE la phrase composé des caractères codés sur deux char ou plus. Puis il affiche SUR
// LA CONSOLE pour chaque caractère les codes qui le définit.

#include <PecheuxGraph_ILI9341_8bits.h>

int c;
String s="àáâçèéêëîï°±òóôµö÷ùúûü€";

void setup() 
{
  Serial.begin(115200);
  Serial.println();
  Serial.println(s);
  for (byte i=0; i<44; i+=2)
    Serial.println(String(s[i])+String(s[i+1])+"  "+String(byte(s[i]))+"  "+String(byte(s[i+1])));
  for (byte i=44; i<45; i+=3)
    Serial.println(String(s[i])+String(s[i+1])+String(s[i+2])+"  "+String(byte(s[i]))+"  "+String(byte(s[i+1]))+"  "+String(byte(s[i+2])));
}

void loop()
{
}

Résultat sur la console série:

àáâçèéêëîï°±òóôµö÷ùúûü€
à  195  160
á  195  161
â  195  162
ç  195  167
è  195  168
é  195  169
ê  195  170
ë  195  171
î  195  174
ï  195  175
°  194  176
±  194  177
ò  195  178
ó  195  179
ô  195  180
µ  194  181
ö  195  182
÷  195  183
ù  195  185
ú  195  186
û  195  187
ü  195  188
€  226  130  172

 

fillMode   <<     >>   setTextSize()