Se connecter

S'inscrire

Découverte d’Arduino

Arduino_Uno_logo

Arduino est un circuit imprimé en matériel libre (open hardware) sur lequel un micro-contrôleur peut être programmé afin de réaliser différentes opérations.

 


1 - Découverte de la carte Arduino

La carte Arduino utilisée lors de cette découverte est le modèle Uno, c’est le modèle de référence des plateformes Arduino et elle dispose de tout le nécessaire pour faire fonctionner le micro-contrôleur.

arduino_uno_components

L’emplacement de certains éléments comme le bouton Reset peut varier suivant les versions de la carte. La carte utilisée pour ce tutoriel est une carte Arduino Uno SMD.

On retrouve dans toutes les cartes  :

  • USB Plug : Le port USB semblable à celui des imprimantes pour discuter avec l’ordinateur.
  • External Power Supply : L’entrée pour une alimentation autre que USB (pour pouvoir fonctionner sur batterie par exemple)
  • Atmega328 : Le micro-contrôleur de la carte, c’est le cerveau de la carte qui stock le programme et l’exécute.
  • Les Pins : Il existe deux types de pins, analogique et numérique. Ces petits trous permettent de brancher des jumpers pour toutes les entrées/sorties.
  • Reset Button : Le bouton Reset permet de relancer le programme.

2 - Découverte du logiciel Arduino

Après installation du logiciel (le lien est disponible en ressource), l’interface du logiciel ressemble à ça : arduino_logiciel

On peut voir que le logiciel ressemble à un éditeur de texte simple.

Alors maintenant qu’on a une carte et le logiciel Arduino qu’est ce que on peut en faire ?

 


3 - Premier TP - Partie développement

Tous les tutoriels semblent commencer par là, alors je vais faire de même.

La grande force d’Arduino repose dans ces nombreux exemples intégrés au logiciel qui permettent de se familiariser avec le code et s’utilisent comme des briques entre-eux. Tout ces exemples se retrouve dans fichier/exemples. Arduino nous apprend donc comment faire des copier-coller intelligents.

Il faut donc aller chercher l’exemple Blink (clignotement) dans les menus.

tp1

L’objectif de se TP est de faire clignoter une LED de façon répétée.

Explication du code

Pour des raisons de lisibilité, les couleurs ne sont pas les mêmes que sur Arduino, le principe reste cependant identique.

codeBlinkTP1

On retrouve différentes couleurs dans ce code .

Les commentaires longs : ils sont précédés de /* et finissent par */.

Les commentaires cours : ils sont précédés de // et ne s’écrivent que sur une ligne.

Les commentaires sont ignorés par l’Arduino, cependant ils restent très importants et permettent de comprendre le fonctionnement du code.

Notez le caractère ; à la fin des lignes. C’est une information pour indiquer la fin d’une action. Ce caractère est indispensable à chaque fin d’action pour que le programme fonctionne correctement.

« void setup () » et « void loop() » : Ce sont les fonctions de base de l’Arduino.

« void setup () »

Il s’agit de l’initialisation de l’Arduino, du démarrage.

Tout ce qui se situe entre les { } ne sera effectué qu’au démarrage de l’Arduino ou lors de l’appuie sur la touche Reset.

Une analogie : c’est le check-up d’un avion avant son décollage, une fois l’avion décollé on ne vérifie plus.

« void loop () »

C’est une boucle infini où tout ce qui se trouve entre les { } vas être répété indéfiniment tant que l’Arduino est sous tension.

Lorsque l’avion est en vol, je retrouverais à l’intérieur : vérification de l’altitude, vérification de la trajectoire, correction de l’altitude ou de la trajectoire, etc.

(L’analogie de l’avion reste moyenne car il n’y a pas de fonction d’arrêt pour l’Arduino. On le débranche simplement, il n’y a pas de phase d’atterrissage).

décomposition de setup:

  • pinMode (13, OUTPUT) ; // C’est l’information nécessaire à l’Arduino pour initialiser la pin 13. Dans l’exemple il s’agit de faire clignoter une LED branchée sur cette sortie. Je lui indique donc que le « mode » de la pin numéro 13 est une sortie (OUTPUT).

décomposition de loop :

On rentre alors dans la fonction void loop ()

  • digitalWrite (13, HIGH) ; / /On indique sur cette ligne une action à effectuer. J’écris sur la pin digital 13 une valeur haute, pour simplifier, j’envoie du courant sur la sortie 13.
  • delay(1000) ; //J’attends 1000 millisecondes soit une seconde.
  • digitalWrite (13, LOW) ; // J’écris sur la pin digital 13 une valeur basse, plus simplement, on éteint la pin 13
  • delay(1000) ; //J’ attends de nouveau une seconde.

Il ne reste plus qu’à envoyer le programme sur la carte Arduino.

Pour cela, il faut connecter la carte à l’ordinateur via un câble USB, choisir le modèle de la carte dans le menu Outils ainsi que le port USB où elle est branchée. (Normalement le port se sélectionne tout seul).

Puis, je clic sur la petite flèche en haut à gauche pour téléverser le programme.

interfaceBlink

Si tout se passe bien, la petite LED (entourée en rouge) doit clignoter à intervalle régulier d’une seconde, cette LED correspond à la sortie 13 de la carte. La LED entourée en vert est celle qui montre si la carte est allumée ou non.

carteBlink

Ok mais si je veux une vrai LED ?


4 - Premier TP - Partie électronique

Alors, nous allons découvrir une deuxième facette d’Adruino, l’électronique.

On retrouve sur internet pour tous les exemples Arduino, des schémas de montage.

Voici celui pour l’exemple Blink :

electroniqueBlinkTP1

On retrouve sur cette image la carte Arduino, une platine d’expérimentation, une LED, ainsi qu’une résistance de 1k Ohms. Les codes couleurs des résistances sont disponibles en ressource.

Une fois le montage réalisé et le programme téléversé, nous devrions retrouver notre clignotement sur la LED. (suivant la LED, la résistance doit être ajustée, si la lumière est faible, une résistance plus faible devrait arranger tout ça).

Est-ce vraiment indispensable d’avoir une carte Arduino pour faire clignoter une LED ?

Bien sûr ce premier exemple a pour vocation d’expliquer le fonctionnement de la carte. Vos amis électroniciens vous dirons sûrement qu’il existe d’autre façon moins onéreuse de faire clignoter une LED qu’avec une carte Arduino.

L’intérêt de la carte viendra au fur et à mesure des tutoriels, ne vous inquiétez pas.


5 - Deuxième TP : Le feu rouge

Nous avons déjà réussi à brancher et contrôler une LED grâce à la carte Arduino.

Grâce aux compétences acquises, nous sommes normalement déjà capables de réaliser notre second TP : un feu tricolore.

Matériel nécessaire :

  • 1 platine d’expérimentation
  • 1 LED rouge
  • 1 LED orange/jaune
  • 1 LED verte
  • 3 résistance de 1kOhms (à adapter suivant les leds)
  • quelque jumpers (les petits câbles)

montageTP2

Il est maintenant l’heure de se lancer pour la réalisation du montage (en photo ci-dessus) et du code qui va avec celui-ci.

Pour vous simplifier la tache, reportez vous au code et au montage effectuer pour l’exemple Blink.


6 - Deuxième TP : Aide

Pour ceux qui ont besoin ou qui se sentent un peu perdu, une petite aide ne fait pas de mal :

Partie électronique :

Normalement pas de soucis pour cette partie, le montage est le même que pour une LED mais ce coup-ci nous allons en brancher trois. Chacune aura sa résistance et sera branché sur une entrée différente.

  • LED verte : pin 13
  • LED jaune : pin 12
  • LED rouge : pin 11

Partie code :

Pour vous facilité la tache voila ce que le code doit faire :

  1. on allume la LED verte
  2. on attend 3 secondes
  3. on éteint la LED verte
  4. on allume la LED jaune
  5. on attend 1 secondes
  6. on éteint la LED jaune
  7. on allume la LED rouge
  8. on attend 3 secondes
  9. on éteint la LED rouge

 


7 - Deuxième TP : Correction

Voici maintenant la correction du second TP pour vous permettre de comparer.

Le code :

codeFeuTP2

et le circuit :

electroniqueFeuTP2


8 - Les constantes et les variables

Nous allons donc découvrir les constantes.

Une constante qu’est-ce que c’est ?

Une constante est comme son nom l’indique une valeur qui sera constante au cours du programme.

Je pourrais par exemple nommer une constante pinLedRouge dans laquelle je vais ranger le nombre 11.

A chaque fois que j’aurais besoin du numéro de la pin de la LED rouge je pourrais aller chercher dans la « boite » pinLedRouge pour récupérer le nombre 11.

Quel intérêt, c’est plus long d’écrire pinLedRouge que 11 !

En effet les constantes seront plus longues à inscrire, cependant, lorsque mon montage changera, par exemple ma LED rouge est maintenant branchée sur la pin 10, je n’ai qu’à changer le nombre à l’intérieur de la boite pinLedRouge pour changer le code.

Voici donc le code du feu tricolore incluant les fameuses constantes :

constanteTP2

on indique donc :

const int pinLedVerte = 13 ;

ce qui signifie : Je déclare une constante nommée pinLedVerte qui contient le nombre 13.

On peut par la suite indiquer à pinLedVerte dès que l’on a besoin de son numéro de pin.

Notez l’emplacement où l’on déclare ces constantes. Elles sont situées au-dessus de la fonction setup().

En effet, les constantes ne peuvent pas sortir d’une fonction. On doit donc déclarer nos constantes à l’extérieur de ces fonctions.

Les variables :

Les variables sont, comme les constantes, des boites dans lesquels nous allons pouvoir ranger des choses.

La différence avec les constantes est que nous allons pouvoir au fur et à mesure de notre programme changer ce qui est à l’intérieur de cette boite.

Elles sont déclarées comme ceci :

int maVariable = 1 ;

J’ai créé une variable ayant pour nom maVariable et elle contient 1.

Une variable peut contenir différentes choses :

  • Des nombres : positif, entier, négatif, à virgule
  • Du texte
  • Des booleen (vrai/faux)

Chaque variable que l’on va utiliser va prendre de la place dans la mémoire de l’Arduino.

Il est important de bien choisir le type de variable en fonction de son utilisation

Les plus importantes sont :

boolean maVariable = true ;

boolean est une variable à deux états TRUE (vrai) (1) ou FALSE (faux) (0)

elle occupe très peu d’espace dans la mémoire de l’Arduino (1 bit)

int maVariable = 15 ;

int est un nombre entier de – 32 768 à 32 767

elle occupe un peu d’espace dans l’Arduino (16 bits)

long maVariable = 43520 ;

long est un nombre entier de – 2 147 483 648 à 2 147 483 647

elle occupe beaucoup de place (32 bits)

float maVariable = 1.23 ;

float est une variable pouvant contenir des nombre a virgule de -3.4028235E+38 à 3.4028235E+38

elle occupe beaucoup de place (32 bits)

String maVariable = « Bonjour » ;

string est une variable contenant du texte ( ! On ne peut pas effectuer d’opération sur un nombre dans une variable de type string! )

D’autres variables moins utilisé existe, la liste complète est disponible en ressource.


9 - Analogique et Numérique

Analogique / Numérique :

Lorsque l’on regarde notre carte Arduino, nous pouvons observer qu’il y a deux types d’entrée/sortie sur la carte.

Celles numérotées de 0 à 13 d’un côté de la carte regroupées sous le terme : Numérique (Digital en anglais)

Et les autres numérotées de A0 à A5 regroupées sous le titre : Analogique

Quelle est la différence ?

Le numérique en Arduino correspond aux composant ayant deux positions. Un interrupteur par exemple sera ouvert ou fermé. L’Arduino lira une valeur 0 ou 1. Ou encore une LED sera allumée ou éteinte, il n’y a pas de position milieu.

L’analogique en Arduino correspond à des capteurs comme un variateur. Nous allons en effet pouvoir faire varier le signal de complètement ouvert (0) à complètement fermé (1023). Entre les deux, différentes positions peuvent être enregistré.

Quelques exemples :

  • Un bouton : deux positions 0 ou 1 : digital
  • un capteur de pression : 1024 positions : analogique
  • photorésistance : 1024 positions : analogique

Oula ! Les constantes, les variables, l’analogique, le digital. Ça fait beaucoup d’un coup tout ça !

En effet nous sommes obligés de faire appel à beaucoup de notions différentes, rassurez vous, cela vous paraîtra beaucoup plus claire avec un peu de pratique.

En parlant de ça, place à un nouveau TP !


10 - Troisième TP - Le bouton

Matériel :

  • un bouton poussoir
  • une résistance 10kOhms
  • une platine d’expérimentation
  • un Arduino
  • Quelque jumper

Nous allons comme dans le premier TP blink, faire appel à la bibliothèque d’exemple d’Arduino.

Pour cela : fichier/exemple/digital/button

Le montage correspondant a été trouvé sur internet : http://arduino.cc/en/tutorial/button

montage TP3

Si le code et le montage ont bien été fait, vous devriez voir la LED de la pin 13 s’allumer lors de la pression sur le bouton.

Le code :

codeTP3

On retrouve dans cet exemple des choses que l’on connaît déjà :

const int buttonPin = 2 ;

Cela défini une constante appelé buttonPin contenant la valeur 2.

Cette valeur correspond à la Pin Digital numéro 2 sur laquelle nous brancherons le bouton.

int buttonState = 0 ;

Cela défini une variable entière appelée buttonState contenant la valeur 0.

L’état du bouton n’aura que deux positions, allumé ou éteint car c’est une entrée digitale. On ne pourrait pas utiliser une variable bool ?

En effet l’exemple utilise ici une variable entière mais on pourrai la remplacer par un booléen. Cela utiliserai moins de mémoire et remplirai très bien la fonction de cette variable.

void setup ()

Dans ce check up, on définit les rôles des pins utilisées, rien de nouveau pour vous.

void loop()

buttonState = digitalRead(buttonPin) ;

Voici une nouvelle fonction, digitalRead. Elle agit comme la fonction digitalWrite que l’on a vu précédemment, mais au lieu d’une sortie il s’agit d’une entrée.

On va donc écrire la valeur présente sur la pin digital buttonPin dans la variable buttonState.

Par exemple si on appuis sur le bouton, la valeur est haute ( = 1 ) on stock donc cette valeur dans la variable buttonState.

Ensuite, c’est ici que ça deviens intéressant :

if (buttonState == HIGH) {

digitalWrite (ledPin, HIGH) ;

}

Traduisons cette instruction en français :

Si la variable buttonState est égal à une valeur haute (1) {

alors on écrit sur la pin digital ledPin une valeur haute (1) ;

}

Ceci est donc une condition « si ». Le symbole « == » correspond à « est égal à ».

Donc si la condition est vrai (si buttonState est bien égal à HIGH) alors on fait tout se qui est présent entre les symboles « { » et « } » (on allume la LED).

On remarque que les conditions ne doivent pas se terminer par le symbole ;

La suite du code peut-être traduite de la même façon et signifie :

Sinon {

on écrit une valeur basse sur la pin digital ledPin

}

L’électronique :

Un bouton poussoir « classique » est dit normalement ouvert (NO)

Il possède 4 pattes branchées comme ci-dessous :  boutonTP3

boutonLogiqueTP3

Quand on appui sur le bouton (représenté par la barre oblique au milieu), le contact se ferme entre les pattes 1 et 2.

Voici le schéma électrique du montage du bouton en Arduino :

arduino2TP3

Quand le bouton est relâché (position ouverte), la pin 2 est relié à la masse et est donc égale à LOW.

Quand le bouton est appuyé (position fermée), la pin 2 est relié au 5V et est donc égale à HIGH.

La résistance sert à éviter les court-circuits entre le +5V et la masse lorsque le bouton est pressé.

La « mise à la terre » de l’entrée digital 2 permet d’éviter les interférences lorsque le bouton est ouvert. En effet, en électronique, de nombreuse interférences peuvent compromettre le fonctionnement. (champs magnétique…). Pour éviter que l’entrée soit parasitée, on l’a relie à la masse, cela « évacue » donc les parasites vers la masse plutôt que vers l’entrée de l’Arduino.

Et enfin une représentation plus parlante  :

arduinoMaquetteTP3

Vous savez maintenant utiliser les boutons avec l’Arduino !


Découverte d’Arduino

Réalisé par , mise en ligne le 10 juillet 2015 - Dernière modification : 10 juillet 2015

Documenter