Quand je parles de "lourd", je parles en terme de calcul internes et/ou mémoire utilisée, pas de syntaxe (donc pour beaucoup de programmes ça ne pose aucun problème, c'est que pour les quelques un où on est limité en vitesse d'exécution ou en mémoire qu'il faut se poser la question).
Pour afficher un nombre différent de 2 chiffres après la virgule, il faut faire une conversion explicite en String, ce qui permet d'ajouter un argument optionnel : le nombre de chiffres après la virgule :
int x=777;
float y=-888.12345;
long z=-999999999;
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.print(String() +("\n\t x = ") +x +("\t y = ") +String(y,3) +("\t z = ") +z);
delay(1000);
}
Le code affiche maintenant 3 chiffres après la virgule.
Si javais mis juste String(y), ça aurait mis les 2 chiffres par défaut.
Pour x et y (des entiers), on ne peut pas préciser le nombre de chiffres après la virgule (ou alors il faut convertir en float : par exemple String( (float)x,1) donnera 777.0 ). En revanche, on peut choisir la base dans laquelle on les affiche : String(x) ou String(x, DEC) : par défaut, en décimal ; String(x, HEX) : en héxadécimal (base 16), String(x, BIN) : en binaire.
A noter que Serial.print(ln) offre les mêmes options de formatage (nombre de chiffres après la virgule, BIN/DEC/HEX).
Attention, un float contient "seulement" 23 bits pour le "nombre" de base (+1 pour le signe et 8 pour l'exposant), donc ça ne fait qu'une précision de 6 à 7 chiffres au total. Donc si tu as un nombre avec 4 chiffres avant la virgule, et que tu demandes 4 chiffres en plus après la virgule, le dernier est aléatoire, et le précédent peut avoir une légère erreur. Une fois que tu fais des calculs sur des floats, les erreurs s'accumulent, donc tu peux considérer qu'au mieux tu as 5-6 chiffres significatifs, si tu fais du n'importe quoi, tu en aura aucun (par exemple : (1.0 + 0.00000000000001 - 1.0)*100000000000000 vaut 0.0, alors que (1.0 - 1.0+ 0.00000000000001)*100000000000000 vaut 1.0
Si tu veux afficher un nombre fixe de caractères pour un float, tu peux faire :
String(y,10).substring(0,4)
où 10 est un nombre assez grand pour être sur d'avoir assez de décimales
et 4 est le nombre de caractères que tu souhaites (nb : la virgule compte)
Si tu veux un nombre fixe de caractères pour un int/long, ça devient plus complexe, et je n'ai plus de solution compacte :
String s1="00000000"+String(x);
String s2=s1.substring(s1.length()-4);
Serial.print(String()+"x="+s2);
//en plus compact :
String s1="00000000"+String(x);
Serial.print(String()+"x="+s1.substring(s1.length()-4););
où 4 est le nombre de caractères à afficher.
Nb : si tu préfères des espaces à des 0, il suffit de rajouter "000000000" par " "