Coffre Ã code avec Arduino

De Wikidebrouillard.

Version du 25 janvier 2013 à 11:28

Article incomplet en cours de rédaction

Sommaire

1 Présentation de l'expérience
2 Matériel
3 L'expérience
4 Explications
5 Liens avec d'autres expériences
- 5.1 Expériences sur Wikidébrouillard
6 Applications : liens avec le quotidien
7 Catégories
8 Test

Présentation de l'expérience

Vous voulez protéger vos biens personnels, le coffre Arduino est fait pour vous!

Marre de votre sœur qui vient voler votre argent de poche ? Marre de votre mère qui cherche à obtenir des informations dans votre journal intime? Choisissez le Coffre Arduino pour les mettre à l'abri.

Matériel

Un ordinateur avec le logiciel Arduino
Un câble USB_A USB_B

	1 Arduino uno.
	26 fils.
	5 Diodes.
	5 Résistance 450Ω.
	Plaque Labtec.
Fichier:Potentiomètre.jpg	Un potentiomètre.
	4 boutons poussoirs.
	2 servos-moteur.
	Un buzzer

L'expérience

La réalisation

1. Câblez chaque LED avec sa résistance associée sur plaque Labtec comme sur la photo. (Résistance reliée à la masse, le plus long côté de la LED sur le +5V).
2. On relie chaque LED à l'Arduino. (de préférence du fil noir pour la masse) Et on relie le +5V au +. ???
3. On câble le Potentiomètre :
La patte du milieu sur l'entrée 0 de l'analogique.
La patte de gauche (la tige du potentiomètre vers nous) sur la masse.
La patte de droite sur le +5V.
4. On câble les boutons poussoirs. (la partie délicate!) Résistance de 10kΩ qui part de la patte du bouton poussoir va à la masse et l'autre patte du bouton poussoir au +5V. À refaire 4 fois.
5. Relier les LED sur les différentes sorties de l'Arduino :
LED 1 sortie 13
LED 2 sortie 12
LED 3 sortie 11
LED 4 sortie 10
LED 5 sortie 9
6. On connecte les boutons poussoirs aux entrées de l'Arduino :
BP 1 pin 2
BP 2 pin 3
BP 3 pin 4
BP 4 pin 5
7. On câble le buzzer :
Partie rouge sur sortie 8 de l'Arduino.
Partie noire sur la masse.
8. On câble les Servos-moteur :
Fil marron sur la masse.
Fil rouge sur le +5V.
Fil orange sur l'une des deux sorties (6 ou 7)
à refaire une fois pour l'autre Servo-moteur.

Le code

/*
  * ===========================================================================================================================================================================
  * ======================================================================Le coffre Fort Arduino===============================================================================
  * ===========================================================================================================================================================================
  *
  *
  * ====================LE CONTEXTE====================
  * L'idée de faire ce projet de coffre a été initié lors d'un atelier des petits debrouillards de Brest auquel les élèves de L'Ecole Nationale d'Ingénieurs de Brest ( ENIB ) ont participé durant l'intersemestre 2012/2013
  * Ceci dans l'objectif de le téléverser sur le wikidebrouillard.
  *
  * ====================LE PRINCIPE====================
  * L'idée est de faire un coffre à code controlé par une carte arduino.
  * Ce coffre à code sera composé de 5 LED, 1 potentiomètre et 4 boutons, ainsi que 2 servomoteurs.
  * Par defaut, le code est composé de 5 verrous: il faut bien positionner le potentiomètre (allumer le bon nombre de LED), puis composer un code à 4 chiffre
  * si l'utilisateur le veut, il peut changer le code, l'agrandir ou bien le réduire, en modifiant le code ci-dessous à un endroit particulier
  *
  * ====================LE CODE========================
  * Ce code permet de gerer les entrées et sorties de la carte Arduino.
  *
  * Réalisé par les élèves de l'Ecole Nationale D'ingénieurs de Brest:
  * Clément Le Fay
  * Glen Bertrand
  * Timothée Marescot
  * Simon Teneau
  * 
  * Réalisé en Janvier 2013
 */
 
 //La ligne ci-dessous importe la librairie "Servo.h" qui contient une liste de fonction permettant d'utiliser des servomoteurs
#include <Servo.h> 

/*
  * ================================= Declarations des fonctions du programme =================================
  * Les 3 lignes suivantes permettent de prévenir le logiciel que plus loin dans le code nous allons fabriquer 3 fonctions: remiseZeroCode,ouvrirCode et afficherCodeActuel.
  * Cela nous permet d'utiliser ces fonctions, qui sont dès lors connues par le programme, avant meme d'avoir besoin de les implémenter ( définir le code qui constituera ces fonctions )
*/

void remiseZeroCode(void);
void ouvrirPorte(int value);
void afficherCodeActuel(void);

/*
  * ================================= Fin de la déclaration des fonctions =================================
  *
  *
  *
  *
  *================================= Definition des Variables globales du programme =================================
*/

/*
  * Variables definissant sur quels entrées et sorties sont placés les composants
  * Variables d'entrée, ce sont des variables de type "int" car on met des nombres entiers à l'interieur
*/

int sensorPin = 0;     // select the input pin for the potentiometer - le potentiomètre est placé sur l'entrée 0 de l'arduino (attention, entrée analogiques)
int switchPin1 = 2;    // input switch 1 - interrupteur sur la patte 2 de l'arduino ( entrée numérique )
int switchPin2 = 3;    // input switch 2 - interrupteur sur la patte 3 de l'arduino ( entrée numérique )
int switchPin3 = 4;    // input switch 3 - interrupteur sur la patte 4 de l'arduino ( entrée numérique )
int switchPin4 = 5;    // input switch 4 - interrupteur sur la patte 5 de l'arduino ( entrée numérique )

//============

/*
  * Variables pour les Led
  * Variables de sortie, ce sont des variables de type "int" car on met des nombres entiers à l'interieur
*/

int ledPin1 = 13;      // select the pin for the LED1 - La led 1 doit être placée sur l'entrée/sortie numérique 13 de l'arduino
int ledPin2 = 12;      // select the pin for the LED2 - La led 2 doit être placée sur l'entrée/sortie numérique 12 de l'arduino
int ledPin3 = 11;      // select the pin for the LED3 - La led 3 doit être placée sur l'entrée/sortie numérique 11 de l'arduino
int ledPin4 = 10;      // select the pin for the LED4 - La led 4 doit être placée sur l'entrée/sortie numérique 10 de l'arduino
int ledPin5 = 9;      // select the pin for the LED5 - La led 5 ( blanche qui signale l'ouverture du coffre) doit être placée sur l'entrée/sortie numérique 9 de l'arduino

//============

/*
  * Ici, nous définissons deux variables qui permettront de commander les deux servomoteurs qui ouvrent la porte
  * Ce sont des variables de type Servo, un type de variable qui a été importé avec la bibliothèque servo.h en début de programme
*/

Servo servoPorte; 
Servo servoPorte2;

//============

/*
 * //======================================================
 * //=========== DEFINITION DU CODE D'OUVERTURE ===========
 * 
 * Ci dessous, c'est une partie très importante dans notre programme, puisque elle définit le code d'ouverture du coffre !
 * Vous pouvez modifier le code à volonté et le tester ensuite pour vérifier que ça fonctionne !
*/

// définit la taille du code d'ouverture, modifiez le 5 par le nombre de votre choix
const int sizeCode=5;
/*
  * le code qu'il faut rentrer si on veut ouvrir le coffre. Votre code doit être homogène avec le nombre rentré précedemment, par exemple ici nous avons un code à 4 chiffre: 2,1,3,4.
  * L'ordre est bien sur important, et chaque chiffre doit être séparé du précédent par une ","
  * Attention, il s'agit bien ici d'un code à 4 chiffres, meme si le tableau fait 5 cases.
  * En effet, le premier chiffre correspond à la position du potentiomètre. le 3 signifie 3 LED allumées à la surface du coffre, ce chiffre est bien sur modifiable, dans un intervalle de 1 à 4
*/
int code[sizeCode]={3,2,1,3,4};    
//cette variable contient à tout instant le code que l'on a rentré via les boutons. Ici, on le rempli de zero !
int codeActuel[sizeCode]={0}; 

//Variables qui permettent de faire fonctionner le programme, elles indiquent la situation des différentes parties du coffre à un moment donné
int emplacementActuelTableau=1;   //indexeur sur le tableau codeActuel
int porteOuverte=0;     //Indique quand la porte est ouverte (1) ou fermée (0)
int ouverturePorte=1;   //Indique quand il faut ouvrir la porte(1), ou la fermer (0);
int antirebond=0;       //permet d'éviter qu'à la suite d'un appui sur plusieurs boutons simultanément ou un appui long, le code tapé soit mal interpreté.
                        //permet également d'éviter qu'un appui court sur un bouton soit compté plusieurs fois dans le programme
int alarme=0;


//Variables qui permettent de recupérer les valeurs du potentiomètre et du bouton
int sensorValue = 0;     //recupère la valeur du potentiomètre
int sensorSwitch1 = 0;   //recupère la valeur du bouton poussoir 1
int sensorSwitch2 = 0;   //recupère la valeur du bouton poussoir2
int sensorSwitch3 = 0;   //recupère la valeur du bouton poussoir3
int sensorSwitch4 = 0;   //recupère la valeur du bouton poussoir4

/*
  * ================================= Fin de la définition des variables globales ==================
  * 
  * 
  *
  * ================================= Début de programme principal =================================
*/

//Phase D'initialisation du programme avec la fonction setup qui est la première appelée lorsqu'on lance le programme
void setup() {

  //Ci-dessous, nous déclarons que les pins associées aux variables ledPin1,ledPin2, .... déclarées précedemment, seront utilisées comme des sorties.
  pinMode(ledPin1, OUTPUT);  
  pinMode(ledPin2, OUTPUT);  
  pinMode(ledPin3, OUTPUT);  
  pinMode(ledPin4, OUTPUT);  
  pinMode(ledPin5, OUTPUT); 
  .
  //Indique la vitesse de raffraichissement de la liaison série entre l'ordinateur et la carte Arduino.
  Serial.begin(9600);
  
  //Ci-dessous, nous déclarons que les pins associées aux variables switchPin1,switchPin2, .... déclarées précedemment, seront configurées comme des entrées.
  pinMode(switchPin1, INPUT);  
  pinMode(switchPin2, INPUT); 
  pinMode(switchPin3, INPUT); 
  pinMode(switchPin4, INPUT); 
  
  //Pour les servomoteurs, c'est un peu particulier, il faut utiliser les fonctions contenu dans la librairie servo.h pour les initialiser.
  servoPorte.attach(6);  //Indique que le servomoteur numero 1 de la porte sera sur la pin 6 de l'arduino
  servoPorte.write(0);   //Indique au servomoteur sa Position initiale. ( la valeur entre "(NOMBRE)" est située entre 0 et 180°.), la fonction write() permet de donner une position au servomoteur
  servoPorte2.attach(7); //Indique que le servomoteur numero 2 de la porte sera sur la pin 7 de l'arduino
  servoPorte2.write(180);//Indique au servomoteur sa Position initiale. ( la valeur entre "(NOMBRE)" est située entre 0 et 180°)
  
}

//============

/*
  * Définition d'une fonction ouvrirPorte qui prend un paramètre value.
  * Si value est égal à 1, la porte s'ouvre.
  * Si value est égal à 0, la porte se ferme.
*/
void ouvrirPorte(int value)
{
  //Ceci est une condition: le if veut dire "SI"
  //Si la condition entre parenthèse est vraie, on éxecute les instructions entre crochets
  if (value==1) 
  {
     servoPorte.write(90);    //Ordonne le déplacement des servomoteurs en position ouverte
     servoPorte2.write(90);
     digitalWrite(ledPin5, HIGH);  //Allumage de la led signalant l'ouverture de la porte
     porteOuverte=1;               //On met cette variable à 1 pour dire que la porte est ouverte !
  }
  if (value==0)
  {
    servoPorte.write(0);  //Ordonne le déplacement des servomoteurs en position fermée
    servoPorte2.write(180);
    digitalWrite(ledPin5, LOW);    //Extinction de la led de la porte
    porteOuverte=0;            //la porte est refermée, cette variable est donc mise à zero
  }
}

//============

/*
    * Cette fonction, lorsqu'elle est appelée, permet de faire un reset du code qui a été rentré précédemment.
    * Celà permet, par exemple en cause de mauvaise manipulation, de recomposer le code !
*/
void remiseZeroCode(void)
{
    for ( int i=0; i<sizeCode;i++)    //On passe autant de fois que nécéssaire (la taille du code), pour faire le reset ! D'ou l'interet d'une boucle pour ce faire
    {
         codeActuel[i]=0; 
    }
}

//============

/*
    * Cette fonction, permet d'afficher le code actuel qui a été saisi au niveau de la liaison série.
*/

void afficherCodeActuel(void)
{
     Serial.println("--------Affichage du code actuel-------");
     Serial.print(codeActuel[0]);
     Serial.print(codeActuel[1]);
     Serial.print(codeActuel[2]);
     Serial.print(codeActuel[3]);
     Serial.println(codeActuel[4]);
}

//============

void loop() {
  // Ici, on charge dans les différentes variables les valeurs recuillies par les capteurs
  sensorValue = analogRead(sensorPin);                //Valeur potentiomètre
  sensorSwitch1 = digitalRead(switchPin1);            //valeur Switch 1
  sensorSwitch2 = digitalRead(switchPin2);            //valeur Switch 2
  sensorSwitch3 = digitalRead(switchPin3);            //valeur Switch 3
  sensorSwitch4 = digitalRead(switchPin4);            //valeur Switch 4

 /*
    * Ci dessous, en commentaire, des instructions permettant l'affichage des différentes valeurs recueillies par les capteurs.
    * Ce procédé: affiché les valeurs, nous a permis de vérifier le bon fonctionnement du programme durant son élaboration.
    *
    * Petite précision: La fonction Serial.print("VOTRETEXTEOUVARIABLE"); permet d'afficher sur la liaison série ce que vous voulez.
    * LA liaison série, c'est celle qui est établie entre la carte et l'ordinateur via le calbe USB !
    *
    * Pour voir ces informations, dans le logiciel arduino, allez dans outils, puis moniteur Série.
    * 
    * Une légère diférence est à remarquer entre la fonction print et la fonction println, puisque cette dernière permet de sauter une ligne de manière automatique !
 */


/*
  //Affichage des valeurs
  Serial.print("Valeur Potentiometre");
  Serial.println (sensorValue);
  Serial.print("Valeur Switch 1 : ");
  Serial.println (sensorSwitch1);
  Serial.print("Valeur Switch 2 : ");
  Serial.println (sensorSwitch2);
  Serial.print("Valeur Switch 3 : ");
  Serial.println (sensorSwitch3);
  Serial.print("Valeur Switch 4 : ");
  Serial.println (sensorSwitch4);
  
 //Affichage du code actuel
  Serial.println("--------Affichage du code vise-------");
 Serial.print(code[0]);
 Serial.print(code[1]);
 Serial.print(code[2]);
 Serial.print(code[3]);
 Serial.println(code[4]);
 
 Serial.println("--------Affichage du code actuel-------");
 Serial.print(codeActuel[0]);
 Serial.print(codeActuel[1]);
 Serial.print(codeActuel[2]);
 Serial.print(codeActuel[3]);
 Serial.println(codeActuel[4]);
*/

//==================================================================================
//ALLUMAGE DES LED EN FONCTION DE LA POSITION DU POTENTIOMETRE
  /*
      * Allumage des LED en fonction de la position du potentiomètre: 1,2,3 ou 4 LED allumées
  */

  digitalWrite(ledPin1, HIGH); //Première led tout le temps allumé  ( témoignant que l'on est en mode de fonctionnement normal )
  if (sensorValue<1000)
  {
    if (sensorValue>250)
    {
       digitalWrite(ledPin2, HIGH); //Allumage Deuxième LED si on a assez tourné le potentiomètre
       codeActuel[0]=2;
       if (sensorValue>500)
       {
           digitalWrite(ledPin3, HIGH);//Allumage Troisème  LED si on a assez tourné le potentiomètre
           codeActuel[0]=3;
           if (sensorValue>750)
           {
               digitalWrite(ledPin4, HIGH); //Allumage Quatrième  LED  si on a assez tourné le potentiomètre ( quasiment en butée )
               codeActuel[0]=4;
           }
       }
    }
  }
  else //POSITION RESET, butée du potentiomètre, on effectue la remise à zéro des variables, et la fermeture du coffre et la coupure de l'alarme si besoin
  {
    remiseZeroCode();                //Appel à la fonction de remise à zero du code rentré
    digitalWrite(ledPin1, LOW);      //on coupe toutes les LED !
    digitalWrite(ledPin2, LOW);
    digitalWrite(ledPin3, LOW);
    digitalWrite(ledPin4, LOW);
    emplacementActuelTableau=1;      //On revient en situation initiale dans la tableau, pret à de nouveau le remplir avec la sequence de chiffre fourni par l'utilisateur
    
    //commande fermeture Porte
    ouvrirPorte(0);                  //On appelle la fonction ouvrirPorte en lui envoyant la valeur 0 -----> on lui demande de refermer la porte
    alarme=0;                        //On coupe le signal d'alarme !
    noTone(8); 
  }
  
  //============================================
  //Gestion extinction des LED
  /*
      * De meme que pour l'allumage des LED, on fait divers tests sur la valeur du potentiomètre pour savoir à quel endroit il est actuelement, puis on éteint les LED si besoin.
  */
  if (sensorValue < 750)
  {
      digitalWrite(ledPin4, LOW);    
      codeActuel[0]=3;
  }
  if (sensorValue < 500)
  {
     digitalWrite(ledPin3, LOW);
     codeActuel[0]=2;
  }
  if (sensorValue < 250)
  {
    digitalWrite(ledPin2, LOW);
    codeActuel[0]=1;
  }
  
  
  //============================================
  //Gestion de l'arret de l'antirebond
  /*
      * Si tout les boutons sont relachés, on peut couper l'antirebond
      * 
      * Antirebond: permet d'éviter un appui simultané sur des boutons, et sa prise en compte plusieurs fois dans le code.
  */
  if((sensorSwitch1==LOW) && (sensorSwitch2==LOW)&& (sensorSwitch3==LOW) && (sensorSwitch4==LOW))
  {
      antirebond=0;
  }
  
  //============================================
  //Gestion des boutons
  /*
       * C'est ici que sont gérées les différentes actions associées aux boutons!
       * Quand on appui sur un bouton, son numero est rentré dans le tableau contenant le code de l'utilisateur.
       * à cet instant, on affiche le code actuellement contenu dans le tableau, puis on active l'antirebond qui ne sera desactivé que quand il n'y aura plus d'actions sur les boutons
       * si l'antirebond est activé ( =1), on n'effectue plus d'actions sur les boutons ( condition if ! )
  */
  if (antirebond==0)
  {
    if((sensorSwitch1==HIGH) && (sensorSwitch2==LOW)&& (sensorSwitch3==LOW) && (sensorSwitch4==LOW))
    {
        Serial.println("Passage switch 1");
       codeActuel[emplacementActuelTableau]=1;
       emplacementActuelTableau+=1;
        afficherCodeActuel();
        antirebond=1; 
    }
    else if((sensorSwitch2==HIGH) && (sensorSwitch1==LOW)&& (sensorSwitch3==LOW) && (sensorSwitch4==LOW))
    {
       Serial.println("Passage switch 2");
       codeActuel[emplacementActuelTableau]=2;
       emplacementActuelTableau+=1;
       afficherCodeActuel();
         antirebond=1;
    }
    else if((sensorSwitch1==LOW) && (sensorSwitch2==LOW)&& (sensorSwitch3==HIGH) && (sensorSwitch4==LOW))
    {
       Serial.println("Passage switch 3");
       codeActuel[emplacementActuelTableau]=3;
       emplacementActuelTableau+=1;
       afficherCodeActuel();
       antirebond=1;
    }
    else if((sensorSwitch1==LOW) && (sensorSwitch2==LOW)&& (sensorSwitch3==LOW) && (sensorSwitch4==HIGH))
    {
       Serial.println("Passage switch 4");
       codeActuel[emplacementActuelTableau]=4;
       emplacementActuelTableau+=1;
       afficherCodeActuel();
         antirebond=1;
    }
  }
  
  ouverturePorte=1; //Variable mise à 1 par defaut
  
  //===============================================================
  //test codeTableau comparé au code que l'on doit rentrer
  /*
      * Une boucle qui permet de détecter si il y a une erreur dans le code, et donc de décider s'il faut ou non ouvrir ou fermer la porte du coffre
  */
  for ( int i=0; i< sizeCode;i++)
  {
     if (code[i]!=codeActuel[i])
     {
       ouverturePorte=0; // si une anomalie dans le code est detectée, mise à zero de la variable, la porte restera donc fermée pour ce passage dans la fonction loop
     }
  }
  
  //===============================================================
  //Alarme si mauvais code rentré
  /*
       * Le code ci dessous permet de déterminer s'il faut oui ou non ouvrir l'alarme.
       * Si le code rentré par l'utilisateur ne correspond pas à celui défini dans le programme, la variable alarme est mise à 1, ce qui déclenche le bruit du buzzer.
       * on compare chaque composante du tableau initial à celui de l'utilisateur, pour celà on utilise une boucle for qui fait la taille du tableau.
       * L'alarme ne peut être allumé que si le potentiomètre n'est pas en position reset (  sensorValue<1000 ), et seulement si la porte est fermée ( porteOuverte==0 )
  */
  if ((codeActuel[4]!=0) && (sensorValue<1000) && (porteOuverte==0))
  {
     for ( int i=0; i< sizeCode;i++)
      {
         if (code[i]!=codeActuel[i])
         {
           tone(8, 494, 500);
           alarme=1;
         }
      } 
  }

  //===============================================================
  //Gestion ouverture Porte
  /*
    * Si on demande l'ouverture de la porte ( variable OuverturePorte ==1 ), et si l'alarme est coupée ( alarme ==0 ), on demande à ouvrir la porte avec la fonction ouvrirPorte qui prend en paramètre 1.
  */
  if ((ouverturePorte==1) && (alarme==0))
  {
     //COMMANDE OUVERTURE PORTE!
     ouvrirPorte(1);  
  }      


  /*
      *  //===============================================================
      * Arrivé à cet endroit du programme, nous sommes à la fin de la liste d'instructions.
      * Le programme reboucle alors et repart au début de la fonction Loop, en reprenant une à une les instrutions précédentes, jusqu'a l'arret de la carte ou l'insertion d'un nouveau programme )
      * 
      * 
      * Nous vous remercions d'avoir pris le temps de nous lire et d'avoir suivi cette expérience.
      * Bon courage pour la réalisation de votre coffre arduino.
      ****** les élèves de l'ENIB******
      *  //===============================================================
  */  
}

La manipulation

1. Brancher l'Arduino à l'ordinateur à l'aide du câble USB.
2. 0uvrir le code du Coffre avec le logiciel Arduino.
3. Téléverser le code dans l'Arduino.
4. Régler le potentiomètre dans la bonne position (en fonction des diodes allumées).
5. Rentrer le code sur les boutons poussoirs.
6. Si erreur dans le code, tourner le potentiomètre à fond (position reset) jusqu'à ce que toutes les diodes s'éteignent. (Rappel : Cela remet le code à zéro) Puis retourner au point 4.
7. Si le code est bon, observer l'allumage de la diode blanche et l'ouverture du coffre.
8. Pour refermer le coffre, tourner le potentiomètre à fond (en position reset).

Que voit-on ?

Lorsque l'on saisi le bon code, un certain nombre de LED s'allument et la porte du Coffre s'ouvre.

Des astuces ?

Il faut bien penser à mettre toutes les masses entres elles.
Ne rien mettre sur les entrés/sorties 0 et 1 de l'Arduino en numérique.
Si on met les résistances en séries (l'une après l'autre) alors les valeurs s'additionnent pour obtenir la valeur de la résistance souhaitée.

Explications

De manière simple

L'Arduino permet de détecter si la combinaison rentrée par l'utilisateur (potentiomètre + boutons) correspond à celle de l'Arduino. Si c'est le cas, alors l'Arduino commande le servo-moteur pour ouvrir la porte et la LED blanche d'ouverture. L'Arduino est capable de réaliser cela grâce à un programme.

Questions sans réponses

Pourquoi utiliser un potentiomètre alors que des boutons suffisent?
Possibilité de changer le code sans rentrer dans le programme?

Allons plus loin dans l'explication

Qu'est-ce qu'un programme? C'est une suite d'instructions et de conditions permettant à l'Arduino de traiter et envoyer des informations par ses entrées/sorties. Le programme contient différentes variables, conditions et fonctions.

Quelques exemples :

int nomDeVariable = 10;

**crée une variable nomDeVariable qui porte la valeur 10**

nomDeVariable1 = nomDeVariable2;

**met la valeur de nomDeVariable2 remplace celle contenue dans nomDeVariable1**

conditions :

if ( nomDeVariable1 > nomDeVariable2)
    {intruction1;
    intruction2;
    …
    }

**condition vraie si la valeur de nomDeVariable1 est supérieure à la valeur de nomDeVariable2. On effectue alors les instructions entre accolades qui suivent, sinon on continue le programme**

boucles :

while (nomDeVariable1 > nomDeVariable2)
    {instruction1;
    instruction2;
    …
    }

**condition vraie si la valeur de nomDeVariable1 est supérieure à la valeur de nomDeVariable2. On effectue alors les instructions entre accolades qui suivent tant que la condition de la boucle est respectée**

fonctions :

nomDeFonction1( )
    {instruction1;
    instruction2;
    …
    return;
    }

**lorsque la fonction nomDeFonction1 est appelée dans le code, les instructions s’exécutent les unes après les autres dans l'ordre : instruction1, instruction2, etc...**

Liens avec d'autres expériences

Expériences sur Wikidébrouillard

Baladez vous sur la thématique Arduino du Wikidébrouillard!

Applications : liens avec le quotidien

Protection des biens personnels, chasse au trésor ou encore découverte de l'Arduino, ce Coffre à code n'attend que vous.

Test

1. Câblez chaque LED avec sa résistance associée sur plaque Labtec comme sur la photo. (Résistance reliée à la masse, le plus long côté de la LED sur le +5V).
2. On relie la masse de l'Arduino à la ligne correspondant à la masse sur la plaque Labtec (de préférence du fil noir pour la masse). Puis on relie le +5V de l'Arduino à la ligne '+5V' sur la plaque Labtec.
3. On câble le Potentiomètre : La patte du milieu sur l'entrée 0 de l'analogique. La patte de gauche (la tige du potentiomètre vers nous) sur la masse. La patte de droite sur le +5V.
4. On câble les boutons poussoirs. (la partie délicate!) Résistance de 10kΩ qui part de la patte du bouton poussoir va à la masse et l'autre patte du bouton poussoir au +5V. À refaire 4 fois.
5. Relier les LED sur les différentes sorties de l'Arduino : LED 1 sortie 13 LED 2 sortie 12 LED 3 sortie 11 LED 4 sortie 10 LED 5 sortie 9
6. On connecte les boutons poussoirs aux entrées de l'Arduino : BP 1 entrée 2 BP 2 entrée 3 BP 3 entrée 4 BP 4 entrée 5
7. On câble le buzzer : Partie rouge sur sortie 8 de l'Arduino. Partie noire sur la masse.
8. On câble les Servos-moteur : Fil marron sur la masse. Fil rouge sur le +5V. Fil orange sur l'une des deux sorties (6 ou 7) à refaire une fois pour l'autre Servo-moteur.