sao1
Bac STI2D

Arduino : Introduction à la programmation

Noms :  
Centre d'intérêt : CI 2 Instrumentation / Acquisition et restitution de grandeurs physiques
Classe : Sti2d Sin
Id programme : sin15, sin31  
Conditions : En Binôme , durée  5 heures.
Matériel : - PC
- Carte Arduino (Hardware)
Logiciel : - Logiciel Arduino (Software)
- Utiliser le navigateur chrome
Document : - Langage arduino

I. Objectifs

  • Etudier un micontrolleur;
  • Introduction à la programmation en C++.

II. Présentation

Matériel nécessaire :

Un module Arduino UNO   Une platine d'interface DangerShield
   

                 

d'un cordon USB :  et de quelques composants électroniques (BP, résistance, fil) :

Les connexions à réaliser : connectez le cordon USB entre l'ordinateur et la carte Arduino.


 

Remarque N°1: à chaque découverte de nouvelle fonction, vous la noterez sur votre fiche de révision. Cela vous permettra de vous faire une liste d'instructions et de fonctions utilisables sur Arduino

Remarque N°2: vous avez un compte rendu à faire (sous forme numérique si vous voulez). Dans ce compte rendu il doit y avoir la réponse au questions mais aussi et surtout les programmes que vous avez fait ou modifiés.

 

III. Découverte du système Arduino

Matériel nécessaire :

Un module Arduino UNO   :                 




Un cordon USB


Les connexions à réaliser : connectez le cordon USB entre l'ordinateur et la carte Arduino.


3.1. La carte arduino : Hardware

La carte Arduino Uno que nous allons utiliser est une sorte de petit ordinateur. Il possède un microcontrôleur (microprocesseur + mémoire+ interface de gestion des entrées/sorties).

La carte Arduino UNO :




Il possède donc des entrées / sorties logiques (« digital » en anglais), des entrées analogiques (0 à 5V), des moyens de communication série et bien sûr un résonateur à quartz d'une fréquence de 16MHz.

 

3.2. Premiers programmes


Ressources disponibles :
Vous disposez de différentes ressources concernant Arduino:  classeurs, documents numériques (language Arduino.pdf) et le site internet officiel http://arduino.cc/ sur l'onglet « reference" notamment (attention à ne pas faire de traduction automatique de la page car les logiciels de traduction ne fonctionnent pas bien avec des explications technologiques).

 


L'algorithmie :
L'algorithme est une suite d’instructions, qui une fois exécutée correctement, conduit à un résultat donné. Pour comprendre, expliquer, analyser un programme nous allons utiliser l'algorithmie sous forme graphique (organigramme) plus facilement compréhensible quand la problématique est simple.

Norme :

Symboles normalisés Commentaires:
Les tests ou branchements conditionnels :
la pointe vers le haut est l'entrée du test,
la pointe avec le rond est le résultat du test lorsqu'il est faux,
la pointe vers le bas est le résultat du test lorsqu'il est vrai.
Mise à disposition d'une information à traiter ou enregistrement d'une information traitée.
Appel de sous programme (appelé aussi « fonction » sous arduino)

 

Quelques structures algorithmiques:

Séquence linéaire

Séquence alternative


"si…alors…sinon"

Séquence répétitive


"tant que…faire…"

Séquence répétitive


"répéter…jusqu'à…"

Début
 "Traitement1"
 "Traitement2"
Fin
Si "condition"
   alors "Traitement 1"
   sinon "Traitement 2"
Fin si
Tant que "condition"
    faire "traitement"
Fin tant que
Répéter "traitement"
jusqu'à "condition"

 

 

3.2.1. Structure d'un programme Arduino:

La structure de base d'un programme Arduino (sketch) :

 

 

 

variables         (déclaration des variables)

void setup()
         {
                 Commandes d'initialisation (entrées, sorties, ...)
          }

void loop()
          {
                Instructions ;
          }

A savoir :
  • La structure void setup() n'est éxécutée qu'une seule fois.
  • La structure void loop() est exécuté indéfiniment (Loop = boucle)
  • La ligne de commentaires : // ... tout texte après les deux slashs est un commentaire.
  • Le bloc de commentaires : /*        */ tout texte entre les deux étoiles est un commentaire, le texte peut s'étendre sur plusieurs lignes.

 

3.2. Les premiers programmes simples


a)  Programme N°1 : clignotement d'une led

Après avoir lancé le logiciel Arduino :
Écrivez (ou copiez) le programme (sketch) suivant en respectant très exactement la mise en page :

 

/* début du programme
Nom : Cligno_LED13
Fonctionnement : Commande sans arrêt le clignotement d'une LED.
Les temps ON (active ou allumée) et OFF (inactive ou éteinte) sont identiques : 0.1s. La LED celle connectée sur la broche 13.
*/

void setup()
{
    pinMode(13, OUTPUT);     // la broche 13 est définie en sortie.
}

void loop()
{
    digitalWrite(13, HIGH);     // allume la LED
    delay(100);     // attend, en ms, le temps indiqué entre parenthèse
   digitalWrite(13, LOW);     // éteint la LED
   delay(100);     // attend, en ms, le temps indiqué entre parenthèse
}
    //fin du programme//

 

Ce programme fait clignoter la LED du module Arduino toutes les 0.2 secondes (ON-OFF). L'expression ON-OFF représente la période. Ici la durée ON est égale à la durée OFF (0,1 s).

  • l'instruction pinMode
    
     

Voici ce que dit la documentation Arduino:

pinMode()


Description
Configures the specified pin to behave either as an input or an output. See the description of digital pins for details on the functionality of the pins.

As of Arduino 1.0.1, it is possible to enable the internal pullup resistors with the mode INPUT_PULLUP. Additionally, the INPUT mode explicitly disables the internal pullups.


Syntax
pinMode(pin, mode)


Parameters
pin: the number of the pin whose mode you wish to set

mode: INPUT, OUTPUT, or INPUT_PULLUP. (see the digital pins page for a more complete description of the functionality.)

....

 

en résumé: pinMode ( n° de broche, [OUTPUT ou INPUT] ) ; déclare la broche « n° de broche » en entrée ou en sortie. Cela ne concerne que les entrées numériques (appelées aussi Tout Ou Rien. En anglais: digital)

 

  • l'instruction digitalWrite:
    
     

Voici ce que dit la documentation Arduino:

digitalWrite()

Description
Write a HIGH or a LOW value to a digital pin.

If the pin has been configured as an OUTPUT with pinMode(), its voltage will be set to the corresponding value: 5V (or 3.3V on 3.3V boards) for HIGH, 0V (ground) for LOW.

If the pin is configured as an INPUT, digitalWrite() will enable (HIGH) or disable (LOW) the internal pullup on the input pin. It is recommended to set the pinMode() to INPUT_PULLUP to enable the internal pull-up resistor. See the digital pins tutorial for more information.

NOTE: If you do not set the pinMode() to OUTPUT, and connect an LED to a pin, when calling digitalWrite(HIGH), the LED may appear dim. Without explicitly setting pinMode(), digitalWrite() will have enabled the internal pull-up resistor, which acts like a large current-limiting resistor.

Syntax
digitalWrite(pin, value)

Parameters
pin: the pin number

value: HIGH or LOW

....

 

en résumé: digitalWrite ( n° de broche, [HIGH ou LOW] ) met un niveau haut (1) ou bas (0) sur la broche désignée.Il s'agit bien d'une sortie logique appelée aussi TOR (Tout Ou Rien) ou digital (en anglais).

 

  • l'instruction delay ():
    
     

Voici ce que dit la documentation Arduino:

delay()

Description
Pauses the program for the amount of time (in miliseconds) specified as parameter. (There are 1000 milliseconds in a second.)


Syntax
delay(ms)

Parameters
ms: the number of milliseconds to pause (unsigned long)

....

 

en résumé: delay (100) : le microcontrôleur de la carte Arduino attend 100 millisecondes.

 

On remarque:

  • que les broches numériques ("Digital Pin" en anglais) peuvent être soit des entrées soit des sorties.
  • quand on veut savoir ce que fait une instruction on se reporte au site internet Arduino qui est la seule source fiable (site en anglais)

 



Sauvegardez ce programme sous le nom : Clign_LED13_NomsDuBinome à l'aide de l'icône représenté en blanc ci-dessous (exemple sur les versions anglaise et française):


Allez dans le menu « croquis » et choisir «vérifier/compiler » (ou CTRL R)

Cette fonction permet de vérifier qu'il n'y a pas d'erreurs de programmation (erreurs de syntaxe)
S'il n'y a pas d’erreurs, chargez (Upload ou téléverser) le programme dans la carte Arduino à l'aide de l'icône représentée en blanc ci-dessous :


Le programme s'exécute dès que le chargement est effectué. Un problème de connexion ? Vérifier le bon choix du port de communication (menu « outil » puis « port série »).
Le driver USB qui était demandé lors de la connexion de la carte Arduino au PC est-il installé ?
Si oui, allez dans le menu Tools- Serial Port, choisissez autre COM3 et relancez le chargement.

La LED clignote ? Oui, c'est gagné. Autrement appelez le professeur et expliquez lui clairement le problème auquel vous êtes confronté.

2.2 Si vous deviez traduite en français la fonction « digitalWrite » comment l’appelleriez-vous ?
2.3 Si vous deviez traduite en français la fonction « delay » comment l'appelleriez-vous ?
2.4 Modifiez maintenant le programme pour que la LED reste allumée pendant 1s et éteinte pendant 2s.

  • Pour constater le changement, n'oubliez pas de recharger le programme dans la carte Arduino après l'avoir modifié. Chronométrez !
  • Faire valider par le professeur

 

Remarque : à chaque modification du programme recopiez celui-ci dans votre compte-rendu.





3.2.5 Modifiez maintenant le programme pour que la LED reste allumée pendant 1s, éteinte pendant 2s puis se rallume 4 secondes, s'éteigne 2s, se rallume 2 secondes et s'éteigne 5 secondes.

  • Pour constater le changement, n'oubliez pas de recharger le programme dans la carte Arduino après l'avoir modifié. Chronométrez !
  • Faire valider par le professeur

 

3.3. Utilisation d-une platine d'essai

 

Faire la suite ici

 

IV. Les variables

Les variables: rôle, choix et utilisation des variables

 

 

4.1. Quelques notions sur les variables

Utilisation de variables

En informatique on a l'habitude d'utiliser des variables que l'on affecte aux valeurs que l'on veut et que l'on peut même modifier tout au long d'un programme. Ces variables sont des symboles qui associent un nom (l'identifiant) à une valeur. Ces variables sont définies en tête de programme (on choisit obligatoirement leur type et on peut aussi leur donner une valeur. Cette valeur peut être ensuite modifiée dans le programme).

Chaque variable a donc une place réservée en mémoire.

On va utiliser la variable de type int : int est l'abréviation d'integer (nombre entier). Placé devant le nom de la variable, il indique que celle-ci est est un nombre entier sur 16 bits.

Exemple :

int duree = 5 ;

             
si dans le programme il y a ça :

 duree = duree + 2 ;  alors la variable « duree » change :

duree

7


si plus loin dans le programme il y a ça :

duree = duree*3 ; alors la variable « duree » change :

duree

21

 





Les fausses variables d'arduino : #define

On va aussi utiliser la fonction « #define ». Celle-ci, bien que moins intéressante que la définition précédente, est très utilisée. Elle ne définit pas la variable mais simplement, lors de la compilation, elle remplace le nom de la variable par la valeur écrite à côté.
Ainsi dans notre programme, #define led 13 signifie que chaque fois que le mot led apparaît dans le programme, celui-ci sera remplacé par 13. Cette valeur ne peut jamais être changée dans le programme. On essaiera quand même au maximum d'utiliser la 1ère écriture (même si notre variable ne change pas de valeur) : int led = 13 ;

 
 

 

4.2. Utilisation des variables

Ouvrir le fichier « clign_led.txt » et récupérer le programme contenu dans le fichier. Copier le dans le logiciel Arduino.

  • Essayez le programme avec votre arduino et décrire ce qu'il fait.
  • Combien y-a-t-il de variables dans ce programme ?
  • Il y a 2 endroits dans le programme où l'on a oublié de mettre une variable (on a utilisé directement la valeur numérique). Modifier le programme pour remplacer cette valeur numérique par une nouvelle variable. Faire valider par le professeur le programme modifié.

 



4.3. Quelques types de variables

Pour répondre aux questions suivantes, utilisez les ressources disponibles: « language Arduino.pdf » sur l'intranet ou le site internet officiel http://arduino.cc/ sur l'onglet « reference ».

4.3.1. Variable « int »

  • Sur combien de bits cette variable est-elle stockée en mémoire ?
  • Combien de valeurs différentes peut-elle contenir ?
  • Donnez la valeur minimum et la valeur maximum que peut prendre une variable de type « int »



4.3.2. Variable « unsigned int »

  • Sur combien de bits cette variable est-elle stockée en mémoire ?
  • Combien de valeurs différentes peut-elle contenir ?
  • Donnez la valeur minimum et la valeur maximum que peut prendre une variable de type «unsigned int » :



4.3.3. Variable « long »

  • Sur combien de bits cette variable est-elle stockée en mémoire ?
  • Combien de valeurs différentes peut-elle contenir ?
  • Donnez la valeur minimum et la valeur maximum que peut prendre une variable de type « long » :



4.3.4. Variable « float »

  • Sur combien de bits cette variable est-elle stockée en mémoire ?
  • Décrire cette variable
  • Donnez la valeur minimum et la valeur maximum que peut prendre une variable de type « float » :
  • Quel est l'intérêt de ce type de variable par rapport à celle du type « int » ?



Remarque : il existe bien d'autres types de variables, adaptés aux besoins des programmeurs.

 

4.4. Choix du type de variable

Complétez le tableau en choisissant la variable adaptée au besoin (Faites valider par le professeur):
(les chiffres après la virgule indiquent la précision)

Nom de la variable

Valeurs possibles

Type de variable à choisir

Tempo

0 à 100 000

 

Adresse_borne

0 ou 1 ou 2 ou 3 ou 4

 

Tension

0,00 à 5,00

 

résultat_cna

0 à 1023

 

température

- 100,00 à 100,00

 

pression

0,0000 à 19,0000

 

 

 

 

 

 

 

 

 

R

 

 

 

 

 

V. Les fonctions ou « sous-programmes »

Rôle, intérêt et utilisation des fonctions

 

 

 

5.1. Quelques notions sur les fonctions/sous programmes

Lorsqu'on a un ensemble de lignes de programme qui doivent être exécutées à différents endroits dans un programme, au lieu de réécrire les mêmes lignes de code, il est intéressant de créer des fonctions.

Exemple du quotidien : le programme « manger » fait appel à la fonction « mettre_la_table »

 

 

5.2. Un exemple avec Arduino

Dans le programme suivant , nous commandons une Led de manière classique :

1. Ouvrez le fichier « clign_led_vers1.txt », récupérez le programme contenu dans le fichier, testez le et analysez comment il fonctionne.

 

On a modifié le programme pour créer une fonction (un sous programme) qui gère l'allumage et l'extinction de la led : « clign_led »
2. Ouvrez le fichier « clign_led_vers2.txt », récupérez le programme contenu dans le fichier, testez le et analysez comment il fonctionne.


3. Où est placé dans le programme cette fonction « clign_led » ?

4. Quelles sont les 3 variables qu'il faut donner à la fonction « clign_led » lorsqu'on l'utilise ?

5. Quelles est l'avantage, d'après vous, qu'il y a à utiliser cette fonction « clign_led » dans notre programme ?

 

 


5.3 Quelques compléments

  • Si on a besoin de variables seulement dans la fonction (on les appelle des variables locales), celles-ci sont déclarées au début de la fonction (c'est la cas ici de la variable « duree »). Les variables déclarées en tête de programme sont, elles, des variables globales et peuvent être utilisées de partout dans le programme.
  • Les éléments entre parenthèses (ici adress_led, temps_allu et temps_arret) sont les paramètres à transmettre dans la fonction. Leur type est directement défini dans la fonction elle même (ici ce sont 3 entiers « int »).
  • L'avantage est que chaque fois qu'on voudra faire clignoter une led, on fera appel à cette fonction clign_led (adresse de la led, temps d'allumage, temps d'extinction). Ce sera plus simple et plus lisible (une seule ligne dans le programme)
  • Une fonction peut renvoyer une valeur (on remplace alors le mot "void" par le type de la variable retournée (ex: int, float, bytes, ...). Exemple ci-dessous d'une fonction qui converti une vitesse de km/h en m/s :
           

        float kmh_vers_ms (float vitesse_en_kmh)
        {
          float calcul;  // definition de la variable calcul
          calcul = (vitesse_en_kmh * 1000)/3600;
          return calcul;
        }

Dans le programme principal on aura par exemple:

        Void loop()

         {

             vitesse_voiture1=117;

             vitesse_voit1_ms = kmh_vers_ms (vitesse_voiture1) ;

         }

 

Le résultat :

         la variable vitesse_voit1_ms sera égale à 32.5

 

 

 

5.4. Exercice d'application:

Soit le programme arduino suivant :

float nombre1;   //………………….
float nombre2;   //………………….
float calcul;   //…………………..
 
void setup() {
}
 
 
float mult_2_val (float val1, float val2)   //…………………..
{
  float resultat;          //…………………..
  resultat = val1*val2;           //…………………..
  return resultat;           //…………………..
}
 
 
 
void loop()         
{
  nombre1=12;
  nombre2=2.5;
  calcul=mult_2_val(nombre1, nombre2);     //…………………..
}



1. Quelles sont les "variables globales" présentes dans le programme Arduino ?
2. Quel est le type de ces variables globales ?
3. Quelle est le nom de la fonction présente dans ce programme Arduino ?
4. Cette fonction a-t-elle des paramètres transmis ? Si oui donnez leur nom.
5. Cette fonction retourne-t-elle un élément. Si oui donnez son nom et son type.
6. Cette fonction contient-elle une variable locale ? Si oui donnez son nom et son type.
7. Compléter le programme Arduino précédent à l'aide de commentaires "intelligents".
8. Expliquer le fonctionnement du programme.

VI. La boucle « FOR »

Rôle, intérêt et utilisation de la boucle « FOR »

 

 

6.1. Fonctionnement de la boucle « For »



Le fonctionnement de la fonction For :


for (initialisation ; condition ; incrément)
{
    bloc d'instructions (actions) ;
}


Fonctionnement : l'initialisation se produit en premier et une seule fois. A chaque passage dans la boucle, la condition est testée; si elle est vraie, le bloc d'instruction et l'incrément (le « pas ») sont exécutés, puis la condition est testée à nouveau. Quand la condition devient fausse, la boucle se termine.
 

 

    
     

Voici un extrait de la documentation Arduino:

for statements

Description

The for statement is used to repeat a block of statements enclosed in curly braces. An increment counter is usually used to increment and terminate the loop. The for statement is useful for any repetitive operation, and is often used in combination with arrays to operate on collections of data/pins.

There are three parts to the for loop header:

for (initialization; condition; increment)  {
     //statement(s);
}


The initialization happens first and exactly once. Each time through the loop, the condition is tested; if it's true, the statement block, and the increment is executed, then the condition is tested again. When the condition becomes false, the loop ends.

....

   


Un exemple :

for (var=0 ; var<4 ; var=var+1)    //boucle For avec variable var , incrément de 1, valeur finale de 4 //
  {
    allumage_led() ;
    appeler_toto() ;    
  }


A l'exécution du programme que se passe-t-il ?

Réponse:

Quand le programme arrive à l'instruction For :
    var est mis à 0
    les fonctions « allumage_led » et « appeler_toto » sont exécutées
    var est mis à 1 (var = var + 1 signifie var = 0 +1 = 1)
    les fonctions « allumage_led » et « appeler_toto » sont exécutées
    var est mis à 2 (var = var + 1 signifie var = 1 +1 = 2)
    les fonctions « allumage_led » et « appeler_toto » sont exécutées
    var est mis à 3 (var = var + 1 signifie var = 2 +1 = 3)
    les fonctions « allumage_led » et « appeler_toto » sont exécutées
    var est mis à 4 (var = var + 1 signifie var = 3 +1 = 4)
    la condition var<4 n'est plus valable, le programme sort de la boucle « For » et passe à la suite

 

6.2. Application de la boucle « For » avec Arduino

1. Copiér le programme ci-dessous dans arduino et testez le.

/**** début du programme **************************************************** 
* Nom : Cligno2vitessesFOR
* Fonctionnement : Commande le clignotement d'une LED.
* AVEC BOUCLES FOR
* Le fonctionnement est identique au programme précédent
***************************************************************************/

#define ledorange 13 // n° de la broche où est connectée la LED orange.

int vitesse1 = 500; // vitesse 1 = 500 ms
int vitesse2 = 250; // vitesse 2 = 250 ms
int vitesse3 = 1000; // vitesse 3 = 1000 ms
int i = 0 ; // variable de la boucle For

void setup()
{
pinMode(ledorange, OUTPUT); // la broche 13 est définie en sortie.
}

void loop()
{
for (i=0;i<3;i=i+1) //boucle For avec variable i , incrément de 1, valeur finale de 3 //
{
digitalWrite(ledorange, HIGH); // allume la LED
delay(vitesse1); // attend, en ms, le temps indiqué entre parenthèse
digitalWrite(ledorange, LOW); // éteint la LED
delay(vitesse1); // attend, en ms, le temps indiqué entre parenthèse
}
delay(vitesse3); // attend, en ms, le temps indiqué entre parenthèse

for (int i=0;i<4;i++) //boucle For avec variable i , incrément de 1, valeur finale de 4 //
{
digitalWrite(ledorange, HIGH); // allume la LED
delay(vitesse2); // attend, en ms, le temps indiqué entre parenthèse
digitalWrite(ledorange, LOW); // éteint la LED
delay(vitesse2); // attend, en ms, le temps indiqué entre parenthèse
}

delay(vitesse3); // attend, en ms, le temps indiqué entre parenthèse
}
// **** fin du programme ****//



2. Que fait le programme ?

3. Modifiez le programme pour avoir 10 clignotements à vitesse 1 et 5 clignotements à vitesse 2. Faites valider par le professeur.

4. Les 2 boucles « For » du programme fonctionnent de la même manière mais il y a  quand même une différence entre les 2 boucles « For ». Quelle est-elle ?

5. Modifiez le programme pour avoir une troisième série de 7 clignotement à une vitesse 4 (100 ms). Faites valider par le professeur.

 

VII. Le test « IF » (+ bouton poussoir)

Rôle, intérêt et utilisation du test  IF …. THEN ….. ELSE

 

 

7.1. Le test conditionnel IF

Le principe :

SI Test vrai
   Instruction 1 exécutée
SINON
   Instruction 2 exécutée
FIN SI
Instruction 3 (suite du programme)
  

     

Voici un extrait de la documentation Arduino:

if (conditional) and ==, !=, <, > (comparison operators)

if, which is used in conjunction with a comparison operator, tests whether a certain condition has been reached, such as an input being above a certain number. The format for an if test is:

if (someVariable > 50)
{
    // do something here
}

The program tests to see if someVariable is greater than 50. If it is, the program takes a particular action. Put another way, if the statement in parentheses is true, the statements inside the brackets are run. If not, the program skips over the code.

The brackets may be omitted after an if statement. If this is done, the next line (defined by the semicolon) becomes the only conditional statement.

 

  if (x > 120) digitalWrite(LEDpin, HIGH);

if (x > 120)
digitalWrite(LEDpin, HIGH);

if (x > 120){ digitalWrite(LEDpin, HIGH); }

if (x > 120){
  digitalWrite(LEDpin1, HIGH);
  digitalWrite(LEDpin2, HIGH);
}        
// all are correct



The statements being evaluated inside the parentheses require the use of one or more operators:
Comparison Operators:

 x == y (x is equal to y)
 x != y (x is not equal to y)
 x <  y (x is less than y)  
 x >  y (x is greater than y)
 x <= y (x is less than or equal to y)
 x >= y (x is greater than or equal to y)


if / else

if/else allows greater control over the flow of code than the basic if statement, by allowing multiple tests to be grouped together. For example, an analog input could be tested and one action taken if the input was less than 500, and another action taken if the input was 500 or greater. The code would look like this:

if (pinFiveInput < 500)
{
  // action A
}
else
{
  // action B
}

....

en résumé cela donne :    
if (test …..)  / / debut du test            
    {     
      instruction 1
    }
  else    
    {
      instruction 2
    }  // fin du test
  les "….." représentent une équation logique. Exemples :
  • a > b
  • a >= b
  • a < b
  • a <= b
  • a == b (noter les deux = sinon a prend la valeur de b)
  • a!= b (si a différent de b)

 

 

 

7.2. Application : appui sur un bouton poussoir

 Objectif du programme : la led s'allume si on appuie sur un bouton poussoir (quand on relâche elle s'éteint)


Principe:

  • On va rajouter un bouton poussoir que l'on va raccorder sur l'entrée numérique (digital) n° 2.
  • On va utiliser un test conditionnel IF

1. Préliminaire : on va tester le bouton poussoir (BP)

 

Placer le BP sur le support de test (bien le mettre au milieu). Ensuite on va prendre un multimètre en position ohmmètre et on va tester le résistance (OL= over limit = résistance infinie c'est à dire contact ouvert, quelques ohm ou zéro ohm = contact fermé).

Faire vérifier le câblage par le professeur.

 

 

Complétez le tableau suivant :

Appui sur BP

Mesure à l'ohmmètre

État du contact (ouvert ou fermé)

État logique (0 ou 1)

OUI

     

NON

     

 

 

2. Le montage complet

Le schéma de raccordement :

Arduino avec Bouton poussoir et LED

Schéma électronique au cicuit ci-dessus est el suivant :

 Circuit électronique équivalent

  

 

A quoi sert la résistance de 10kΩ?

Lorsqu'une broche numérique d'Entrée n'est pas connectée, le niveau présent sur cette broche d'entrée est instable et la LED dans notre programme clignoterait de façon aléatoire. Ceci est du au fait que l'entrée est "flottante", c'est à dire qu'elle n'a pas de connexion matérielle au +5V ou à la masse, et elle oscillera de façon aléatoire entre le niveau HAUT et le niveau BAS. C'est pour cette raison qu'il faut mettre une résistance de "rappel au plus" (appelée aussi résistance de tirage ou pull-up) dans le montage du BP sur la broche numérique en entrée.

  

Faire le petit câblage (le arduino doit être débranché du cordon USB) et faites vérifier par le professeur.

 

 

3. Le programme Arduino

Copier le programme ci-dessous dans arduino et testez le.

//**** début du programme *********//

#define ledorange 10
#define boutonPin 3

// définition des variables
int etat_bouton = 0; // variable de l'état du bouton poussoir

void setup() {
pinMode(ledorange, OUTPUT); // definition de la sortie de la led//
pinMode(boutonPin, INPUT); // définition de l'entrée du bouton (2) //
}

void loop(){

etat_bouton = digitalRead(boutonPin); // lecture du bouton poussoir //

if (etat_bouton == HIGH) // test si le bouton est appuyé //
{
digitalWrite(ledorange, HIGH); // allumage de la led //
}
else // si le bouton n'est pas appuyé //
{
digitalWrite(ledorange, LOW); //extinction de la led //
}
}

//**** fin du programme *********//

 


Compléter l'algorithme du programme :

 

Que constatez-vous ? L'objectif de fonctionnement est-il atteint ? Si ce n'est pas le cas expliquez ce qui se passe (à partir du schéma électronique).

Proposez et essayez une modification du programme. Faire valider par le professeur.

 

 

Le microcontrôleur utilisé sur la carte Arduino dispose d'une résistance interne qu'il est possible d'activer pour réaliser le Pull-up (rappel au plus), ce qui permet de se dispenser d'une résistance externe !

Dans le programme Arduino cela donne:

Le seul changement se situe dans le Setup():

pinMode(boutonPin, INPUT);    //met la broche en entree
digitalWrite(boutonPin, HIGH) ;   // activation du pullup de la broche en entrée

 

Suite du TP ici 

 

Source :  https://sti2d.ecolelamache.org/ap_n21_dcouverte_de_la_programmation_informatique__laide_darduino.html

 

Fil de navigation