Personne ne s’est jamais interrogé sur la façon dont un microcontrôleur apprivoise la notion de temps, et pourtant Arduino, ce petit chef d’orchestre électronique, jongle avec les secondes sans broncher. Ici, on va creuser comment il mesure, attend, calcule, et parfois même improvise avec des nombres. L’attente, le calcul, et la génération aléatoire n’auront plus de secret à la fin de ce tour d’horizon.
Heure
Pour manipuler le temps, une carte Arduino propose quatre outils : delay(), delayMicroseconds(), millis() et micros(). Les deux premiers mettent le programme en pause, en millisecondes ou microsecondes, selon le cas. Les deux autres servent à mesurer le temps écoulé depuis le démarrage du programme. Une petite piqûre de rappel s’impose sur la correspondance des unités : 1 seconde équivaut à 1 000 millisecondes ou 1 000 000 microsecondes. Cette conversion, c’est la base pour ne pas perdre le fil.
A lire aussi : Marketing automation : comprendre cette expérience en ligne
delay()
On a déjà croisé delay(). Elle prend un seul paramètre : la durée de la pause, exprimée en millisecondes, pouvant aller de 0 jusqu’à 4 294 967 295. Mais attention au revers de la médaille : tant que delay() ou delayMicroseconds() sont actives, presque tout le reste est mis en veille. Impossible de lire un capteur, de piloter une broche, bref, le programme est suspendu. Seules les opérations qui échappent au microcontrôleur principal continuent : par exemple, les signaux PWM générés par AnalogWrite() ou les données reçues sur la ligne Rx, stockées dans le tampon en attendant que le programme reprenne son cours.
Exemple de code avec delay()
Voici un exemple d’utilisation concrète :
A lire aussi : Les principaux types d'analyse de données utiles en entreprise
- Déclarer la durée d’attente souhaitée
- Basculer une LED à l’état haut ou bas avec une pause entre chaque changement
Ce schéma simple montre comment créer un clignotement régulier, grâce à delay().
delayMicroseconds()
delayMicroseconds() fonctionne sur le même principe que delay(), mais la pause se compte en microsecondes, entre 0 et 65 535. Même logique, mais à une échelle plus fine.
millis()
Avec millis(), on obtient le nombre de millisecondes écoulées depuis le lancement du programme. Pas besoin de paramètre, la fonction renvoie ce chiffre toute seule. Une limite existe : le compteur s’arrête à 4 294 967 295, puis recommence à zéro (c’est le fameux débordement de minuterie). L’avantage de millis() ? On surveille le temps qui passe sans mettre l’exécution en pause. Parfait pour lancer des actions différées tout en gardant le contrôle.
Un exemple parlant : un programme qui affiche chaque seconde la durée écoulée, directement sur la ligne série, grâce à une variable qui garde la trace du dernier affichage.
Note : le débordement du compteur survient environ tous les 50 jours. (4 294 967 295 ms ≈ 49,7 jours)
micros()
micros() fait la même chose que millis(), mais avec une précision de microsecondes. La valeur maximale reste la même, mais comme une microseconde est mille fois plus courte qu’une milliseconde, le débordement arrive au bout de 71,5 minutes environ. À noter : la résolution dépend de la fréquence du processeur. Sur un Arduino à 16 MHz, la précision est de 4 microsecondes, donc la valeur retournée est toujours un multiple de 4.
Un point de détail technique : les valeurs limites de ces fonctions viennent du type de données utilisé. Les paramètres sont stockés dans des entiers non signés (unsigned int ou unsigned long), qui n’acceptent que des valeurs positives. Par exemple, un unsigned int s’étend de 0 à 65 535, tandis qu’un unsigned long grimpe jusqu’à 4 294 967 295.
Mathématiques
Voyons maintenant ce qu’Arduino propose côté calculs. Avant de se lancer dans les fonctions avancées, petit rappel des opérateurs de base.
Opérateurs mathématiques
On retrouve les classiques : addition (+), soustraction (-), multiplication (*), division (/), et un opérateur un peu moins connu, le modulo (%). Ce dernier donne le reste de la division entière. Par exemple :
- 2 + 1 = 3 (addition)
- 2 – 1 = 1 (soustraction)
- 2 * 3 = 6 (multiplication)
- 9 / 3 = 3 (division)
- 9 % 6 = 3 (modulo, car 9 divisé par 6 donne 1, reste 3)
L’opération modulo trouve son utilité pour tester la divisibilité : si le reste de a % b vaut zéro, alors a est divisible par b.
Exemple de test de divisibilité
Si on veut vérifier qu’un nombre est divisible par un autre, le code se résume à une condition : if (a % b == 0).
min()
La fonction min() sélectionne le plus petit de deux nombres. Pratique pour parcourir un tableau à la recherche de la valeur minimale, ou pour fixer une limite inférieure à une mesure. Voici comment s’en servir pour déterminer la plus petite valeur d’un ensemble :
- Initialiser une variable avec la première valeur du tableau
- Comparer chaque élément suivant avec la valeur courante grâce à min()
- Garder le plus petit à chaque étape
Ce principe permet de protéger un capteur contre un dépassement de seuil, ou simplement d’extraire l’élément le moins élevé d’une série.
max()
max() fonctionne sur le même modèle que min(), mais pour dénicher la valeur la plus élevée. Que ce soit pour surveiller un pic ou mémoriser le record d’une mesure, l’approche reste identique : on compare chaque valeur à la précédente, et on garde la plus grande.
abs()
La fonction abs() renvoie la valeur absolue d’un nombre. Autrement dit, elle ignore le signe : abs(150) donne 150, abs(-150) aussi. Sur un axe, c’est la distance du nombre par rapport à zéro, sans distinction entre positif et négatif.
constrain()
constrain() combine l’idée de min() et max() pour forcer une valeur à rester dans une plage donnée. Trois paramètres : la valeur à ajuster, la borne basse, la borne haute. Si la valeur sort du cadre, elle est ramenée à la limite la plus proche. Sinon, elle reste inchangée. Ce principe évite les dérapages, par exemple quand on veut s’assurer qu’un capteur ne dépasse jamais un certain seuil.
map()
Pour transformer une plage de valeurs en une autre, la fonction map() fait le travail. Contrairement à constrain(), elle ne coupe pas les valeurs, mais les redistribue sur la nouvelle échelle. Typique : convertir la lecture d’une entrée analogique (0 à 1023) pour piloter la luminosité d’une LED avec un signal PWM (0 à 255). La syntaxe : map(valeur, minOriginal, maxOriginal, minNouveau, maxNouveau).
Exemple d’application de map()
En utilisant un potentiomètre branché sur une entrée analogique, on peut ajuster la luminosité d’une LED de façon fluide, la valeur lue étant automatiquement recalibrée à la plage PWM attendue.
pow()
Lorsqu’il s’agit d’élever un nombre à une puissance, pow() entre en scène. Elle prend deux paramètres : la base et l’exposant. pow(10, 3) donne 1000, pow(2, 5) donne 32. Cette fonction est utile pour les calculs exponentiels, souvent indispensables en traitement du signal ou en gestion d’échelles logarithmiques.
sqrt()
sqrt() retourne la racine carrée du nombre passé en paramètre. sqrt(25) renvoie 5. Simple et direct, parfait pour des calculs de distance ou de géométrie dans des applications embarquées.
Fonctions goniométriques
Avant d’attaquer les fonctions trigonométriques, un mot sur les unités d’angle. On raisonne souvent en degrés, mais mathématiquement, les radians s’imposent. Un tour complet fait 360°, soit 2*PI radians. Pour convertir : radians = (degrés * PI) / 180. Les fonctions trigonométriques servent à calculer longueurs et angles dans les figures planes ou spatiales, et leurs valeurs se répètent de manière périodique.
sin()
La fonction sin() représente le rapport entre le côté opposé et l’hypoténuse dans un triangle rectangle. Son amplitude maximale est 1, sa période 360° ou 2*PI radians. Le paramètre est l’angle (en radians), et la sortie, la valeur du sinus pour cet angle. Par exemple, on peut tracer la courbe d’un sinus en affichant les résultats sur la ligne série.
fonction sinusoïdale
En définitive, Arduino ne se contente pas de calculer : il mesure, attend, ajuste, et transforme. Derrière chaque fonction, un potentiel d’expérimentation et d’invention, prêt à s’activer dès la prochaine ligne de code. Qui saura jusqu’où ces opérations, si concrètes en apparence, pourront conduire les créateurs de demain ?
