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.
#
$menu = ":PG";
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.
#
$menu = ":PG";
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