Lire un entier depuis la console

La console permet de lire facilement un octet ou un caractère. Pour lire un entier, on peur utiliser au moins deux méthodes:
- on lit les caractères les uns après les autres et en analysant les différents caractères lus on les ajoute au nombre que l'on a commencé à lire ou on décide de terminer la lecture
- on lit globalement une chaîne complète et on extrait le nombre caché dedans.

Lecture des caractères un par un

En lisant et en analysant les caractères les uns après les autres, on est plus à même de trier ce qui nous plaît ou pas. Par exemple lors de la lecture d'un entier, on ne devrait lire que des chiffres et éventuellement le signe moins. Si au milieu on trouve autre chose, par exemple une lettre ou un signe de ponctuation, il est possible de l'ignorer ou au contraire le considérer comme un séparateur. on peut aussi, comme on analyse les caractères, accepter les représentation binaires ou hexadécimales.

Avec cette méthode, il est possible de faire la lecture avec une fonction non bloquante.

On va donc regarder tout d'abord si un caractère est présent ou pas. Si il n'y a pas de caractères, on peut retourner à faire autre chose. Si un caractère est présent, on li lit alors. Si c'est un chiffre, on le rajoute à ce qui a déjà été lu. Si c'est un signe moins, on peut ou non en tenir compte. Si c'est un caractère non numérique, on peut soit l'ignorer, soit terminer la lecture.

Voici un programme qui affiche les nombres positifs issus de la console:

//###########################################################################
//###########################################################################
//####                                                                   ####
//####                           Olivier Pécheux                         ####
//####                          Olivier@Pecheux.fr                       ####
//####                         (33) +6 69 77 82 58                       ####
//####                    http://arduino.dansetrad.fr                    ####
//####                                                                   ####
//###########################################################################
//###########################################################################

// Ce programme affiche le nombre entier tapé à la console. Les différents
// chiffres sont lus les uns après les autres.

void setup() 
{
  Serial.begin(115200); // Il faut aussi régler la console sur 115200 bauds
  // Ne pas oublier aussi de choisir dans la console "nouvelle ligne" seulement
}

int nombre = 0; // Contiendra le résultat final

void loop()
{
  if (Serial.available()) // On ne fera l'analyse que si on a un caractère
  {
    char octetLu = Serial.read(); // Lecture caractère par caractère
    if (isDigit(octetLu)) nombre = nombre * 10 + octetLu - '0'; // Ajout du chiffre lu (1)
    else // Fin de l'entier lu (ce n'est plus un chiffre)
    {
       Serial.println(nombre); // C'set le résultat attendu
       nombre = 0; // On est prêt pour recommencer
    }
  }
}

(1) Lorsque l'on donne le chiffre 4 par exemple, la fonction Serial.read() ne nous retourne pas le chiffre 4, mais le code ascii de 4. On a les résultats:

Pour avoir le chiffre correct, il faut retirer systématiquement 49. Ce 49 peut aussi s'écrire '0', c'est le code ascii du chiffre 0. C'est plus facile à retenir et à comprendre.

Lecture globale avec une chaîne

Une deuxième façon est de lire une chaîne de caractère complète et d'extraire en une fois la valeur. C'est simple à coder car on utilise plus de fonctions de la bibliothèque Serial. On va utiliser les fonctions readStringUntil() pour lire la chaîne et toInt() pour extraire la valeur numérique. L'utilisation plus importante de bibliothèques double la taille du code, mais est plus simple à écrire.

Le programme qui suit ne fait qu'attendre une chaîne et l'affiche. Si on prends les valeurs par défaut, il faut qu'après l'appel à readStringUntil(), la chaîne soit complète avent une seconde. C'est trop court. Comme on ne fera rien pendant l'attente, on peut se permettre d'attendre sans limite de temps. Cette limite peut être choisie par Serial.setTimeout() qui attend le temps en millisecondes donné par le paramètre interprété comme un entier positif. Il s'agit d'un unsigned long, et ici on prendra le plus grand possible. Pour ne pas avoir à le calculer, je donne la valeur -1 qui sera transtypée en nombre le plus grand. -1 ne contenant en binaire que des 1 comme le nombre le plus grand.

//###########################################################################
//###########################################################################
//####                                                                   ####
//####                           Olivier Pécheux                         ####
//####                          Olivier@Pecheux.fr                       ####
//####                         (33) +6 69 77 82 58                       ####
//####                    http://arduino.dansetrad.fr                    ####
//####                                                                   ####
//###########################################################################
//###########################################################################

// Ce programme affiche le nombre entier tapé à la console. Les différents
// chiffres sont lus les uns après les autres.

void setup() 
{
  Serial.begin(115200); // Il faut aussi régler la console sur 115200 bauds
  // Ne pas oublier aussi de choisir dans la console "nouvelle ligne"
  Serial.setTimeout(-1); // Temps de saisie illimitée ou presque
}

String lecture; // Chaîne lue
int nombre; // Contiendra le résultat final

void loop()
{
  lecture = Serial.readStringUntil('\n'); // Lecture de la chaîne complète
  nombre = lecture.toInt(); // Récupération de la valeur contenue dans la chaîne
  if (nombre<0) nombre=-nombre; // Au cas où le nombre serait négatif
  Serial.println(nombre); // C'set le résultat attendu
}