Dans cette page, nous verrons les exemples:
- Fading: Utilisons des boucles FOR.
- Smoothing: Utilisons un tableau.
- While statement conditionnal: Boucle WHILE et appel de fonction.
Fading: Utilisons des boucles FOR.
Matériel nécessaire:
- 1 LED (+ sa résistance).
Localisation du programme:
Ce programme se trouve dans Fichier -> Exemples -> 03.Analog -> Fading.
But du programme:
Nous allons faire varier l’intensité lumineuse d’une LED grâce à deux boucles FOR.
Explications du programme:
Rien d’exceptionnel au début du programme, on ne déclare que la borne 9 comme ledPin.
- for (int fadeValue = 0; fadeValue <=255; fadeValue+=5) {: Si les boucles FOR sont pour vous une nouveauté ou si vous avez une mémoire de poisson rouge, voici le lien pour avoir une piqûre de rappel.Nous attaquons donc notre première boucle FOR sous arduino IDE. Décomposons là:
– int fadeValue = 0: Nous déclarons la variable qui évoluera à l’intérieur de notre boucle directement au début de celle ci. Puis nous l’initialisons à 0.
– fadeValue<=255: Nous ne sortirons pas de cette boucle tant que fadeValue sera inférieure ou égale à 255.
– fadeValue+=5: A chaque tour dans la boucle, nous augmenterons la valeur de fadeValue de +5. - analogWrite(ledPin, fadeValue): Nous utilisons la valeur que la boucle FOR fait évoluée (fadeValue) comme consigne de luminosité. Celle ci commencera donc éteinte (fadeValue = 0) et finira à son intensité maximale (fadeValue = 255).
- delay(30): On attend 30 ms, ce qui veut dire qu’en démarrant de 0 jusque 255, par pas de 5, cela fait 255/5=51 tours. A raison de 30ms par tour, la LED passera d’éteinte à allumée à fond en 51*30=1530ms, soit 1,53 secondes.
Ensuite une deuxième boucle qui fait la même chose mais en initialisant fadeValue à 255 (alors que précédemment elle fut initialiser à 0) et diminue de 5 à chaque tour (alors que précédemment nous l’augmentions de 5).
Puis vient l’accolade fermante de la fonction loop(), le programme recommence un nouveau cycle.
Smoothing: Utilisons un tableau.
Matériel nécessaire:
- 1 potentiomètre.
Localisation du programme:
Ce programme se trouve dans Fichier -> Exemples -> 03.Analog -> Smoothing.
But du programme:
Nous allons stocker les dix dernières valeurs lut par l’arduino et en calculer la valeur moyenne.
Explications du programme:
Si vous avez besoin d’un rappel sur ce que sont les tableaux, voici un lien récapitulatif.
Nous commençons le programme par la déclaration des variables.
- const int numReadings = 10: Cette constante fixe le nombre de valeurs dont nous tiendrons compte pour calculer la valeur moyenne.
- int readings[numReadings]: voila la déclaration de notre tableau! Ce tableau se nomme readings et il est composé de [numReadings] (soit 10) emplacements. Pour rappel, cela fait qu’il commence à readings[0] et finit à readings[9].
- int readIndex = 0: nous initialisons à 0 la variable qui nous servira à parcourir le tableau dans le programme.
- int total = 0: stockera la somme des dix variables du tableau.
- int average = 0: sera la valeur moyenne du tableau, obtenue par l’opération total/numReadings.
- int inputPin = A0: Nous nommons l’entrée A0 « inputPin ».
Ensuite vient la fonction setup():
- Serial.begin(9600): Nous commençons par initialiser la communication USB.
- for (int thisReading = 0; thisReading < numReading; thisReading++)
readings[thisReading] = 0;
Ici nous initialisons notre tableau grâce à une boucle FOR. Pour ceci nous déclarons une variable que nous n’utiliserons qu’ici: int thisReading. Nous évoluerons jusque atteindre la valeur fixée par la constante numReadings par pas de 1. Ainsi, dans chaque élément du tableau, nous affecterons la valeur 0.
Initialiser un tableau est quelque chose d’indispensable et une boucle FOR est le moyen le plus fiable et le plus simple de le faire, alors pensez y.
Enfin vient la fonction loop(). Le principe sera d’écrire dans les dix éléments du tableau, et une fois arrivé au dernier, continuer en réécrivant l’élement 0 et continuer ainsi de suite. De cette façon, le tableau sera toujours remplit des 10 dernières valeurs lu. La somme de tous ces éléments divisé par dix donnera la valeur moyenne :
- total = total – readings[readIndex]: nous soustrayons de total (représentant la somme des dix éléments du tableau) la valeur de l’élément du tableau dans lequel nous nous trouvons ( [readIndex] ).
- readings[readIndex] = analogRead(inputPin): Nous stockons la valeur de l’entrée analogique dans l’élément [readIndex] du tableau.
- total = total + readings[readIndex]: Nous ajoutons la nouvelle valeur de readings[readIndex] à la valeur de total. C’est ici que nous additionnons les dix éléments du tableau entre eux.
- readIndex = readIndex + 1: Nous augmentons l’index de +1 pour passer à l’élément suivant du tableau.
- if (readIndex >= numReadings): Nous comparons la valeur de l’index en cours (l’élément du tableau en cours) à la taille maximale du tableau (numReadings). Si elle est supérieur, alors c’est que nous sommes arrivé au dernier élément du tableau, donc nous repassons readIndex à 0 pour recommencer au premier élément.
- readIndex = 0: Ce que nous venons de dire plus haut. Si readIndex dépasse la taille du tableau, alors la remettons à 0.
- average = total / numReadings: Ici nous calculons la valeur moyenne. Nous prenons donc la variable dans laquelle nous avons fait la somme de tous les éléments du tableau que nous divisons par la constante représentant la taille du tableau (numReadings).
- Seril.println(average): Nous envoyons la valeur moyenne à l’ordinateur.
- delay(1): Légère temporisation pour stabiliser l’arduino (à priori).
While statement conditionnal
While statement conditionnal: Boucle WHILE et appel de fonction.
Matériel nécessaire:
- 1 potentiomètre.
- 1 LED (+ sa résistance).
- 1 bouton.
Localisation du programme:
Ce programme se trouve dans Fichier -> Exemples -> 05.Control -> WhileStatementConditionnal.
But du programme:
Nous allons faire varier la luminosité d’une LED en effectuant une mise à l’échelle de l’entrée analogique. Nous y inclurons également la possibilité de « calibrer » notre entrée en faisant appel à une fonction externe.
Explications du programme:
Comme tout programme proprement écrit, celui ci commence par la déclaration des variables:
Les quatre premières constantes sont maintenant classique pour vous. Ce n’est que la nomination des bornes utilisées de l’arduino.
- const int sensorPin sera donc la borne A2 sur laquelle sera raccordé le potentiomètre.
- const int ledPin sera la borne 9 sur laquelle sera raccordé la LED.
- const int indicatorLedPin sera la LED qui indiquera que la calibration est en cours, raccordée sur la borne 13.
- const int buttonPin = 2 sera le bouton permettant de faire la calibration raccordée sur la borne 2.
Puis vient l’initialisation de trois variables:
- int sensorMin = 1023: On définit la valeur minimal du capteur à 1023 (j’explique pourquoi nous mettons la valeur maximal (1023) que l’entrée puisse avoir comme valeur minimale juste après).
- int sensorMax = 0: Valeur maximale du capteur à 0, j’explique pourquoi juste après.
- int sensorValue = 0: Stocke la valeur analogique reçu de la borne A2.
Parlons un peu de sensorMini = 1023 et sensorMax = 0.
La logique voudrait que la valeur mini soit = 0 et maxi = 1023. Mais ici nous allons effectuer une calibration qui fonctionnera comment ceci:
Tant que je reste appuyé sur le bouton de calibration, CHAQUE VALEUR INFÉRIEURE A CELLE DE SENSORMINI SERA STOCKÉE DANS CELLE CI, ET CHAQUE VALEUR SUPÉRIEUR A SENSORMAX SERA STOCKÉE DANS CELLE CI.
Un exemple est toujours plus parlant, alors nous démarrons une première fois le programme. sensorMini est initialisé a 1023 et sensorMax à 0. Maintenant on appuie sur calibration au moment où le potentiomètre vaut 645.
- 645 > 0, donc sensorMax passe de 0 à 645.
- 645< 1023, donc sensorMin passe de 1023 à 645.
Le potentiomètre change de valeur pour arrivé a 410.
- 410 < 645 donc sensorMax reste à 645.
- 410 < 645 donc sensorMini passe de 645 à 410.
Le potentiomètre change de valeur pour arrivé a 960.
- 960 > 645 donc sensorMax passe de 645 à 960.
- 960 > 410 donc sensorMini reste à 410.
Et nous lâchons la bouton de calibration. Résultat, nous avons une valeur minimale de capteur de 410 et une valeur maximale de 960, tout ceci est devenu parfaitement cohérent.
Intéressons nous maintenant à la fonction principale loop():
- while (digitalRead(buttonPin) == HIGH) {: Nous commençons par une boucle WHILE qui tourne tant que le bouton de calibration de la borne 2 (buttonPin) est enfoncé. Si celui ci est au repos, le programme saute directement à la ligne digitalWrite(indicatorLedPin, LOW).
- calibrate(); : Si le programme est entré dans la boucle et tant que le bouton de calibration (buttonPin) reste enfoncé, il éxécute la fonction calibrate() que nous verrons ci dessous (celle ci est écrite en dehors de la boucle principale loop()).
- digitalWrite(indicatorLedPin, LOW): Nous arrivons ici lorsque nous sortons de la boucle ou si nous n’y sommes pas entré. Cette ligne sert à éteindre la LED indicatorLedPin signifiant que la calibration est en cours.
- sensorValue = analogRead(sensorPin): Nous venons stocker la valeur lue par l’entrée analogique dans la variable sensorValue.
- sensorValue = map(sensorValue, sensorMini, sensorMax, 0, 255): Nous mettons à l’échelle sensorValue dans cette même variable (c’est à dire que la variable dans laquelle nous écrivons est sensorValue, et la variable dans la fonction map est aussi sensorValue). La mise à l’échelle se fait des valeurs mini et maxi déterminée lors de la calibration en une valeur allant de 0 à 255 (pour être compatible avec nos sorties analogiques.
- sensorValue = constrain(sensorValue, 0, 255): Ligne importante, celle ci permet de « brider » la valeur sensorValeur mise à l’echelle de 0 à 255.
- analogWrite(ledPin, sensorValue): enfin nous écrivons la sortie analogique ledPin à la valeur de sensorValue.
- }: Accolade fermante de la boucle loop(). Celle ci se termine la et reboucle.
Dans la boucle WHILE de notre programme, nous avons éxécuté la fonction calibrate() qui est écrit à l’extérieure de loop(). Ceci a pour intérêt de:
- Rendre le programme plus clair en n’ayant que la ligne appelant la fonction dans le programme principal. Le reste étant écrit à la fin.
- Rendre la fonction générique. Si vous devez effectuer plusieurs fois la même action, préparez la fonction en bas du programme et lorsque vous en aurez besoin, cela ne vous prendre qu’une seule ligne.
Voici donc la fonction calibrate():
Dans la boucle principale, lorsque le programme rencontre la ligne calibrate(); il saute directement ici pour effectuer cette fonction.
- digitalWrite(indicatorLedPin, HIGH);: Nous commençons par allumer la LED indiquant qu’une calibration est en cours.
- sensorValue(analogRead(sensorPin): Nous stockons la valeur analogique venant du potentiomètre dans la variable sensorValue.
- if (sensorValue > sensorMax) {: Si la valeur lue est supérieur à celle précédemment enregistrée dans sensorMax, alors nous rentrons dans le IF pour enregistrer la nouvelle valeur maximale sensorMax.
- if (sensorValue < sensorMini) {: Si la valeur lue est inférieure à celle précédemment enregistrée dans sensorMini, alors nous rentrons dans le IF pour enregistrer la nouvelle valeur minimale sensorMini.
- Puis nous sortons de la fonction pour retourner dans le programme principal.