IPA06 – Découverte des exemples arduino.

Dans cette page nous verrons:

  • Analog input: Comment lire une entrée analogique pour modifier une durée.
  • Read analog voltage: Comment lire une entrée analogique sur votre PC.
  • Analog In Out Serial: Faire varier l’intensité lumineuse d’une LED et voir leurs valeurs sur votre PC.

Analog input: Comment lire une entrée analogique pour modifier une durée.

Matériel nécessaire:
  • 1 potentiomètre (c’est une résistance variable).
  • 1 LED (+ sa résistance).
Localisation du programme:

Ce programme se trouve dans Fichier -> Exemples -> 03.Analog -> Analoginput.

But du programme:

Le but de ce programme sera de modifier intervalle de clignotement d’une LED grâce à une entrée analogique.

Explications du programme:

Ce programme vous apprendra à utiliser une entrée analogique. Vous verrez qu’il ne sera pas compliqué à comprendre car c’est quasiment le même que Blink.

Arduino analog input: declaration des variables

Dans un premier temps nous déclarons trois variables:

  • int sensorPin = A0: un integer servant à désigner explicitement la borne de l’entrée analogique A0 (sensor signifie capteur en anglais). Sachez que qu’une entrée analogique varie de 0 à 1023 pour 0 à 5V.
  • int ledPin = 13: un integer servant à désigner la borne 13 où sera raccordée la LED.
  • int sensorValue = 0: un integer servant à stocker la valeur retravaillée du capteur analogique.

Puis la fonction setup() qui ne déclare que ledPin (donc la borne 13) comme étant une sortie.

Puis la boucle principale, void loop() {:

Analog input: boucle principale arduino

 

 

  • sensorValue = analogRead(sensorPin): vous découvrez ici une fonction essentielle pour travailler avec les entrées ana: analogRead. Celle ci n’est pas compliquée à comprendre, elle va simplement écrire dans sensorValue la valeur analogique lue sur l borne sensorPin (soit la borne A0). Rappelez vous qu’à ce moment, l’entrée analogique vaut 0 s’il y a 0V, 1023 pour 5V, 511 pour 2.5V…
  • digitalWrite(ledPin, HIGH): Nous connaissons cette ligne, on allume la LED.
  • delay(sensorValue): Ah! La fonction delay() nous connaissons, mais auparavant nous n’utilisions que des nombre en guise d’argument, alors que la c’est une variable. Le delay durera donc le temps (en milliseconde) contenu dans la variable sensorValue (j’expliquerai cela plus précisément après avoir fini l’analyse du programme).
  • digitalWrite(ledPin, LOW): On éteint la LED.
  • delay(sensorValue): La même tempo que ce dessus.
  • L’accolade fermante de la fonction loop, le programme reboucle.

Je ne reviendrai pas sur le clignotement de la LED, nous avons déjà vu un programme faisant cela.

Au début de loop(), nous venons lire et stocker dans sensorValue, l’entrée A0 qui peut aller de 0 à 1023 selon la position du potentiomètre.

Puis vient la succession de clignotement que vous connaissez, mais où delay(1000) est remplacé par delay(sensorValue). Cela signifie que selon la position de votre potentiomètre, cette fonction pourra valoir entre delay(0) jusqu’a delay(1023); soit un clignotement très rapide pour delay(0) jusqu’a une clignotement de 1,023 seconde pour delay(1023).

Petit rappel: Souvenez vous lorsque nous avons parlé de l’exécution des cycles d’un programme. Au début du cycle, le programme va enregistrer l’état de entrée  A0 et la mémoriser dans sensorValue à cette valeur durant tout le cycle. Ce qui veut dire qu’ici, si vous démarrez un cycle avec le potentiomètre à fond (donc votre cycle durera 2,046 secondes), changer la valeur de votre potentiomètre n’affectera pas immédiatement le clignotement, mais attendra de recommencer un nouveau cycle pour prendre cette modification en compte.

Petit rappel 2: Voici un premier lien vers un article détaillant la fonction delay(), et un autre lien pour le rappel du fonctionnement d’un potentiomètre.

Read analog voltage: Comment lire une entrée analogique sur votre PC.

Matériel nécessaire:
  • 1 potentiomètre.
Localisation du programme:

Ce programme se trouve dans Fichier -> Exemples -> 01.Basics -> Readanalogvoltage.

But du programme:

Le but de ce programme sera de lire la valeur d’une entrée analogique, la mettre à l’échelle et la transmettre à votre PC via son câble USB.

Explications du programme:

exemple arduino: read analog voltage

 

La fonction void setup() ne fait qu’une seule chose: initialiser la vitesse de communication USB avec votre PC. Pour l’instant ne modifiez pas cette valeur.

exemple arduino: read analog voltage loop

 

  • int sensorValue = analogRead(A0): Comparez cette ligne avec celle du programme précédent, et voyez ce qui a changé… Vous pouvez remarquer que dans ce programme, nous n’avons déclarer aucune variable, ni avant setup(), ni dans setup(). Ici l’auteur à décider de déclarer la variable sensorValue comme un int directement lors de sa première utilisation. Sachez que ceci est possible, mais que ça rendra moins lisible votre programme (il est plus clair de rassembler toute les variables avant le setup(), ainsi votre programme ne contiendra pas de variables « cachée » en plein millieu de celui ci). Vous pourrez aussi remarquer que l’auteur n’a pas choisit de remplacer A0 par une variable avec un noms plus « explicite » (comme capteurTemperature par exemple).
    Sinon mis à part cette déclaration « sauvage », l’acquisition de la valeur ana est la même que celle de l’exemple précédent.
  • float voltage = sensorValue * (5.0 / 1023.0): Une fois de plus, cet auteur (qui a décidé de resté anonyme) déclare la variable voltage (un float, donc un nombre à virgule) en plein milieu du programme. Alors on s’aperçoit qu’il multiplie la valeur analogique par 5 et divise le tout par 1023. Et bien ceci s’appel une mise à l’échelle.
    Mise à l’échelle: Une mise à l’échelle sert à convertir une valeur « électrique » reçu par un capteur en valeur « physique » représentant ce que l’on mesure réellement. Je vous ait déjà dit que la carte nous envoyez une valeur allant de 0 à 1023 pour une tension en entrée allant de 0 à 5V. Et bien cette opération convertir le sensorValue en une valeur allant de 0 à 5V.
    Si nous mesurions une température grâce à un capteur dont le datasheet (feuille des caractéristiques du composant) qui nous indiquerai qu’il nous renverrait 0V pour 0°C et 5V pour 40°C, alors nous saurions que l’arduino nous renverra 1023 pour une température de 40°C, 0 pour une température de 0°C, 511 pour une température de 20°C… Donc grâce à l’opération sensorValue * (40.0 / 1023.0), nous convertirons la valeur électrique reçu par l’arduino (de 0 a 1023) en valeur physique (de 0 a 40°C). Sachez que dans l’exemple d’après, vous découvrirez une fonction qui fait cela automatiquement, la fonction map().
    Notez ici que comme nous travaillons en float, nous devons rajouter des .0 après toutes nos valeurs.
  • Serial.println(voltage): Cette commande permet d’envoyer la valeur de voltage au votre PC (c’est aussi simple que cela).
  • L’accolade fermante de la fonction loop(), le programme reboucle.
Comment visualiser les valeurs reçupar votre PC?

C’est vrai que ça peut s’avérer pratique… Il faut donc laisser relier votre arduino à votre PC de la même façon que lorsque vous téléversez un programme. Dans arduino IDE, allez dans Outils -> Moniteur série. Une fenetre s’ouvrira et c’est dans celle ci que vous verrez défiler vos variables.

Analog In Out Serial: Faire varier l’intensité lumineuse d’une LED et voir leurs valeurs sur votre PC.

Matériel nécessaire:
  • 1 potentiomètre.
  • 1 LED (+ sa résistance).
Localisation du programme:

Ce programme se trouve dans Fichier -> Exemples -> 03.Analog -> AnalogInOutSerial.

But du programme:

Nous allons faire varier l’intensité lumineuse d’une LED grâce à un potentiomètre ainsi que faire remonter les valeurs du potentiomètre et de la LED sur votre PC.

Explications du programme:

Voici un programme proprement tapé. Celui ci commence par la déclaration des constantes et variables avant la fonction setup().

exemple arduino: analog in out serial 01

  • const int analogInPin = A0: On commence par nommer la borne d’entrée analogique A0 analogInPin en la définissant comme une constante de type integer.
  • const int analogOutPin = 9: On fait de même pour la borne 9 que l’on utilisera comme notre sortie analogique.
  • int sensorValue = 0: On initialise à 0 une variable de type integer qui servira à stocker la valeur lue du potentiomètre.
  • int outputValue = 0: On initialise à 0 une variable de type  integer qui servira à être la consigne de la sortie analogique.

La fonction setup() ne fait qu’initialiser la vitesse de communication du port USB à 9600.

Puis vient la boucle principale loop():

exemple arduino analog in out serial 02

  • sensorValue = analogRead(analogInPin): On commence par lire l’entrée du potentiomètre et stockons sa valeur dans la variable sensorValue.
  • outputValue = map(sensorValue, 0, 1023, 0, 255): Voici une fonction de mise à l’échelle très intéressante, map().
    La fonction map(variableAnalogique, valeurMiniEntree, valeurMaxiEntree, valeurMiniSortie, valeurMaxiSortie) fait automatiquement une mise à l’échelle. Le premier paramètre que vous rentrez (à la place de variableAnalogique) est votre entrée analogique (ou toute autre variable analogique que vous souhitez mettre à l’échelle). Puis les paramètres valeurMiniEntree et valeurMaxiEntree sont les valeurs minimum et maximum que la variableAnalogique peut avoir (par exemple pour une entrée analogique elle sera de 0 à 1023 points). Enfin les paramètres valeurMiniSortie et valeurMaxiSortie sont les valeurs mini et maxi que vous souhaitez affecter à votre mise à l’échelle.Dans notre cas, nous mettons à l’échelle l’entrée analogique sensorValue (soit la borne A0) de 0 à 1023 points vers 0 à 255 points et nous stockons le résultat dans la variable outputValue. Ici nous faisons cela car les sorties analogique sont comprises entre 0 point pour 0V et 255 points pour 5V.
  • AnalogWrite(analogOutPin, outputValue): Nous utilisons cette fonction pour assigner la valeur analogique outputValue à la borne analogOutPin (soit la borne 9).
  • Serial.print(« sensor = « ): Cette fonction sert à afficher le mot entre guillement dans le moniteur série d’arduino IDE. Vous pouvez constater la différence avec le Serial.println vu précédemment. Et bien après l’exécution de la fonction print, on ne revient pas à la ligne, alors qu’après println, il y a un retour à la ligne.
  • Serial.print(sensorValue): Cette fois il n’y a pas de guillemets, donc nous affichons la valeur contenue dans la variable sensorValue.
  • Serial.print(« \t output = « ): Ici nous commençons par \t. Les \ signifient que ce qui suit sera une instruction, et l’occurence \t veut dire « exécute une tabulation ». Après avoir fait cette tabulation, on écrit « output = « .
  • Serial.println(outputValue): Enfin on écrit la valeur contenue dans outputValue et on fait un retour à la ligne.
  • delay(2): Lorsque l’on utilise des sorties analogiques, on temporise toujours légèrement afin que la carte ait le temps de « réagir ».
  • }: Accolade fermante de loop(), le programme reboucle.

Voila, vous pouvez transférer votre programme et ouvrir le moniteur série d’arduino IDE. Vous constaterez que l’intensité de votre LED variera selon la positon du potentiomètre et que leurs deux valeurs remonterons sur votre écran.

Pas mal non?

Pages: 1 2 3