Accueil ISN - TS ICN - 2nde Maths - TS Liens

Introduction à la robotique avec Arduino

Découverte : une led et une résistance

Introduction

Nous allons pendant ces TD travailler sur la plate-forme de prototypage électronique Arduino. Cette plate-forme permet de créer de l’appareillage électronique interactif de manière simple.
Deux versions sont proposées, l’une avec de l’électronique, l’autre sans. Pour ceux qui ont peur de l’électronique, vous commencerez avec les modules Tinkerkit, qui évitent de faire des montages. Vous ferez ensuite, si vous en avez le temps, la version « électronique pure ». Les modules Tinkerkit sont des briques, que l’on connecte tout simplement par des câbles.
Je vous demanderai de faire preuve de mesure et de délicatesse lors des manipulations, les composants sont fragiles. Vous travaillerez à deux. Vous rangerez en fin de séance les composants que vous aurez utilisés dans les bonnes cases, sous peine d’en être privé la fois d’après !
Enfin, si ces TD vous plaisent, vous pouvez prolonger l’expérience chez vous. Un Arduino coûte 20 euros, une boite de composants électroniques (kit de débutants pour Arduino par exemple) dans les 40 euros (on peut trouver moins cher encore, la qualité/solidité sera en conséquence). Et si vous n’avez pas peur de l’anglais, un très bon bouquin, complet : Arduino Cookbook, Michael Margolis, éditions O’Reilly (il existe aussi des livres en français, plus simples et très bien faits, ainsi que des tutoriels sur le net, de qualité variable). Vous pouvez aussi utiliser des modules comme TinkerKit, c’est un peu plus cher et un peu plus simple. Dans ce cas je vous conseille plutôt les modules Grove, Tinkerkit étant en sommeil ces dernières années.

Premier programme

Matériel : vous aurez besoin uniquement d’une carte Arduino et d’un câble USB.

Nous allons faire clignoter une des LED (light emitting diode, diode électro luminescente ou DEL en français) située sur la carte Arduino, sans faire de montage pour l’instant. C’est la diode marquée L sur la carte (repérez-la).
Lancez le programme Arduino sur l’ordinateur. Ce programme est un IDE : environnement de développement. C’est dans ce logiciel qu’on tape les programmes, et qu’on les envoie à la carte Arduino.
Vous devriez pouvoir choisir la langue dans les préférences. Dans outils>carte (Tools>board en anglais), cochez Arduino Uno/Génuino. Allez dans Outils>Port série, regardez quels sont les ports présents. Branchez ensuite la carte arduino via un câble USB. Puis retournez dans Outils>Port Série, vérifiez si la carte apparaît et cochez le port en question. Si elle n’apparaît pas, branchez la carte sur un autre port et recommencez.
Captures d’écran et quelques explications supplémentaires sur le site d'Arduino

Tapez le programme figurant dans la première colonne, dans l’IDE Arduino, en respectant absolument les majuscules et symboles présents :

Programme
Explications
// Programme écrit par Genie_1 et Genie_2 Cette ligne est un commentaire, elle commence par //. On massacre allègrement l’orthographe en ne mettant aucun accent, aucune cédille etc. dans les programmes informatiques. Pour des commentaires de plusieurs lignes, on les écrit entre /* et */
void setup(){ Le « setup » est l’initialisation du programme, qui ne sera exécuté qu’une seule fois au démarrage. On ouvre le setup avec une accolade
    pinMode(13,OUTPUT); On déclare la connexion 13 comme étant une sortie de courant.
Chaque ligne de programme se finit par un point-virgule.
On décale les instructions, d’une tabulation ou de quatre espaces, à chaque fois que l’on ouvre des nouvelles accolades.
} Fermeture du setup
void loop() { Boucle principale, exécutée à l’infini
    digitalWrite(13,HIGH);
    delay(1000);
    digitalWrite(13,LOW);
    delay(1000);
On envoie du courant dans la broche 13.
On attend 1 seconde (1000 millisecondes)
On coupe le courant dans la broche 13.
On attend 1 seconde
} On ferme la boucle principale
Ce programme est écrit dans une variante du langage de programmation C. Le C est un langage très rapide, mais qui n’est pas le plus simple à écrire.
Sauvegardez votre programme, puis téléversez-le dans la carte avec le bouton televerser. Et là c’est MAGIQUE.
Ou alors ça plante : vous avez des commentaires en orange dans la partie en bas de la fenêtre de l’IDE. Si c’est un problème « not in sync », c’est que la carte Arduino n’est pas reconnue sur le port série. Reprenez le début de ce paragraphe. Sinon, c’est probablement un problème de syntaxe (majuscule, point virgule oublié, etc.)
Remarque : je ne vous donne pas les premiers programmes en téléchargement. En effet, il est important de constater par soi-même que la moindre faute de frappe fait tout planter.

Premier montage

Version TinkerKit

Matériel : une carte Tinkerkit (un « shield »), un câble Tinkerkit et un module DEL. Branchez le shield sur l’Arduino, et la diode sur le port O0 (Output 0).
Le programme précédent est transformé comme ceci :

Programme
Commentaires
#include
TKLed led(O0);
void setup() {
}
void loop {
    led.on();
    delay(1000);
    led.off();
    delay(1000);
}
//la bibliotheque TinkerKit permet d’utiliser les modules
// declaration de la DEL en sortie
// rien dans l'initialisation

// on allume la DEL

// on eteint la DEL

Version montage électronique

Matériel et sa description : Une breadbord, une DEL, une résistance de 220 Ohms, deux câbles male/male (un rouge et un bleu si possible, surtout pour le rouge).

La breadbord est une planche de montage expérimentale (ou de prototypage). Elle se présente sous la forme suivante, où les trous de la même couleur sont reliés entre eux.
Les trous d'en haut/bas servent souvent pour le courant. Par convention, on met un fil rouge/marron pour l'entrée, un fil bleu pour la sortie et un fil noir/bicolore pour la terre pour le 220 V. La couleur rouge est impérativement respectée car dangereuse, notamment avec le 220 V : ne touchez jamais un fil rouge ou marron dans une prise ou un interrupteur sans avoir d’abord coupé le courant !
Ci dessous la connexion du courant sur la breadbord, avec un agrandissement du branchement sur la carte.

La diode est un composant électronique qui ne laisse passer le courant que dans un sens. La diode électroluminescente émet en plus de la lumière. Il faut donc la brancher correctement : repérer la patte plus courte et le côté coupé du côté négatif (cathode).

des LED
schéma et symbole LED
des résistances
symbole résistance
Des DEL
Vue d'une DEL avec le sens, et symbole
Diverses résistances, symbole

Il est nécessaire de mettre une résistance avant ou après la diode, sinon le courant est trop fort et va la griller à terme. Un calcul permet de trouver une valeur de 160 ohms. Dans les faits, une résistance entre 100 et 1k ohms est correcte. On met souvent 220 ohms pour une led (rouge rouge marron, vérifier avec la table/méthode ci-dessous). Plus la résistance est forte moins la diode émettra de lumière.

Complément : lecture et calcul de la valeur des résistances

Comme précisé, ce paragraphe est un complément, que vous pouvez lire dans un deuxième temps

La lecture de la valeur des résitances se fait en fontion du nombre d'anneaux de couleur présents. Il y en a 4, 5 ou 6. Sur une résistance à quatre anneaux, les trois premiers donnent les chiffres significatifs, le dernier le multiplicateur (une puissance de 10). Pour les résistances à trois anneaux, on commence la lecture par la couleur située le plus près d'une extrémité. Le tableau wikipedia donne la valeur des couleurs. De nombreux sites calculent la correspondance valeur/couleurs, comme celui-ci ou celui-là, ou encore celui là.

Le calcul des résistances à mettre dans un circuit électrique n'est pas très compliqué, mais demande des connaissances complémentaires à ce que vous connaissez en seconde (et même en terminale me semble-t-il).
Dans un circuit électrique, on note U (ou V) la tension (ou différence de potentiel) en volts, I l’intensité, en ampères, et R la résistance, en ohms. On peut comparer le courant électrique au flot d’une rivière. La tension correspond alors à la différence d’altitude entre la source et l’embouchure : plus la différence est importante, plus le flot coulera fort : un ruisseau de montagne a une « différence de potentiel » plus forte que la Seine. L’intensité correspond au débit du flot d’eau : la Seine a une « intensité » plus grande qu’un ruisseau de montagne.
Les différences de potentiel nous entourant vont de 20/90 mV (nerfs optiques/musculaires), à 1 000 000 V (la foudre), en passant par 1,5 V (les piles), 220 V (les prises de courant), 10 000/500 000 V (lignes à haute tension).

Des sites expliquent comment calculer la résistance nécessaire pour ne pas griller des composants dans un circuit électronique, en utilisant la loi des mailles, la loi des noeuds et la loi d'Ohm. Pour un exemple simple, voir sur OpenClassroom le cours premiers montages avec Arduino, aller à "calcul de la bonne valeur de résistance pour une led".

Montage

Voici une première proposition de montage, à ne pas faire, avec à côté le schéma électronique symbolique :

En fait, nous allons utiliser les broches (pin en anglais) 0 à 13 pour brancher les composants. En effet, le montage ci-dessus envoie du courant en permanence, tandis que l’on peut programmer les broches 0 à 13 pour envoyer le courant quand on le souhaite. Dans les faits, on évite d’utiliser les connexions 0 et 1, qui peuvent servir au port série (que l’on verra ultérieurement) Pour simplifier, on branchera directement le courant sur la colonne de trous où sont les composants, sans passer par les trous du bas (ou du haut).
D’où le montage que l’on réalise (vous pouvez prendre n’importe quelle connexion, sauf 0 et 1) :

Reprendre le programme du 1 et le tester sur votre montage. Attention : déclarer la bonne connexion, ce n’est plus forcément la 13.
Remarque : on peut aussi monter la diode à l’envers : elle sera alors éteinte en mode HIGH et allumée en mode LOW. D’après OpenClassrooms, ce montage économise la carte.

La boucle pour

La boucle pour i de 0 à xxx est une instruction qui répète plusieurs fois fois un bloc d’instructions, en général xxx fois. On dit que c’est une instruction itérative (une itération = une répétition). On utilise un compteur de boucle (itérateur) en général i, j ou k. On précise de combien on augmente le compteur de boucle à chaque itération. Exemples :

En C, la syntaxe du pour est :

for (int i=0; i<10; i++)
{
    // diverses instructions
}

On déclare d’abord le compteur i comme étant un entier (int), qui est crée à la valeur 0 (i = 0). On donne ensuite la condition qui permet d’arrêter la boucle (on continue tant que i < 10 ), et enfin on précise la manière dont on augmente l’itérateur ( i++ ).

Exercices

Tous les exercices seront recopiés dans le dossier documents>devoirs>Mandon ou par email. Ils seront nommés comme suit : ex_arduino_1_1_Nom1_Nom2.ino

(pour le 1er exercice ci-dessous, avec vos noms)

Ex_arduino_1_1

Faire clignoter la diode alternativement deux secondes, puis une seconde (remarque : pas besoin de for).

Ex_arduino_1_2

La diode doit clignoter 10 fois une seconde, puis s’arrêter.

Ex_arduino_1_3

La diode doit d’abord clignoter 5 fois une seconde, ceci une seul fois, puis alterner 10 clignotements rapides d’une demi seconde, et 10 clignotements lents de deux secondes sans fin.

Ex_arduino_1_4

La diode doit clignoter de plus en plus rapidement, puis de plus en plus lentement, et ainsi de suite. Par exemple en millisecondes : 200 – 400 – 600 – 800 – 1000 – 800 – 600 – 400 – 200 – etc... On peut aussi faire 100 – 200 – 400 – 800 – 1600 – 800 – 400 – 200 – 100 – etc...
Remarque : on peut mettre une variable, ou bien un calcul, dans delay(). Les opérations usuelles sont +, - ,* , /. Le nom de la variable est au choix, les usages donnent par exemple tempsEntreDeuxEtats.
Il faut déclarer cette variable en début de programme (dans le setup par exemple on écrira int temps_entre_deux_etats = 100 ; ).

La boucle tant que

La boucle tant que/while est aussi une instruction itérative. Elle répète un bloc d’instruction suivant une condition.
La condition est écrite entre parenthèses, elle peut par exemple être

La différence entre pour et tant que est que pour exécute un nombre de fois prédéterminé le bloc, tandis que le nombre d’itérations du tant que n’est pas déterminé à l’avance.
En C, la syntaxe du « tant que » est :
int i = 0     // declaration de l'iterateur
while (i < nombre)
{
    // diverses instructions
i = i + 1;     // ou i ++, ou autre
              // methode suivant la condition d'arret
}

Exercices

Reprendre les exercices de la boucle pour, en les nommant ex_arduino_1_1bis_Nom1_Nom2.ino etc... Vous me les ferez parvenir aussi (email ou dossier devoirs>Mandon)

Du bon usage des capteurs

Les capteurs et le port série

Découverte du port série

Copiez le programme suivant :

Programme
Commentaires
void setup()
{
  Serial.begin(9600) }
Le port série est ouvert avec une vitesse de lecture de 9600 bps (bits par seconde). Considérez-le comme une ligne téléphonique qui peut envoyer ou recevoir jusqu’à 9600 nombres 0/1 par seconde.
void loop {
  for (int i=1; i<6; i++)
    {
    Serial.println(200*i);
    delay(200*i);
    }
}
On « imprime » à l’écran par le port série le nombre 200*i, avec print.
println signifie qu’en plus on passe à la ligne après avoir écrit le nombre
Une fois le programme téléversé, il faut cliquer sur le bouton port_serie pour ouvrir la fenêtre du port série. Constatez ce qui se passe.

Les senseurs/capteurs

Prenez soit une photorésistance (ou encore light sensor), qui capte la luminosité ambiante, soit une thermistance, qui donne la température ambiante. Les senseurs sont des entrées et non des sorties (INPUT et non OUTPUT).

Avec Tinkerkit :

Branchez le capteur sur l’entrée I0 (input 0).

Instructions
Lumistance
Thermistance
Déclaration en entrée 0 (input 0), à écrire après l’importation de la bibliothèque Tinkerkit. TKLightSensor ldr(I0); TKThermistor therm(I0);
Lecture de la valeur (luminosité ou température).
int luminosite; // variable à déclarer au début du programme (avant le setup)
luminosite = ldr.read(); // lecture dans la "loop" de la valeur (entre 0 à 1023)
int valeur ; // variable à déclarer au début du programme (avant le setup)
float Celsius ; // variable à déclarer au début du programme (avant le setup)
valeur = therm.get() ; // lecture dans la "loop" de la valeur (entre 0 à 1023)
Celsius = therm.getCelsius() ; // la valeur lue est ici donnée en degrés celsius
Version montage électronique

Matériel et sa description : une breadboard, un arduino, 3 cables dont un rouge et un bleu ou noir.
En plus:

Thermistance LM 35
Lumistance
Renvoie un voltage de 10 mV par degrés. Les port d’entrées analogiques renvoient une valeur correspondante entre 0 et 1023. Appelée CDS parfois. Renvoie un voltage variable suivant la luminosité. Les port d’entrées analogiques renvoient une valeur correspondante entre 0 et 1023. On peut utiliser n’importe quelle résistance entre 1 kΩ et 10 kΩ
// en début de programme
const int inTemp = 0; // broche entrée capteur
int valeur; // variable pour la lecture du LM35
float millivolts = 0; /// variable pour la donnée en mV
float celsius; // variable conversion en d° Celsius
// dans la boucle principale
valeur = analogRead(inTemp); // lit la valeur (entre 0 et 1023)
millivolts = (valeur/1023.0)*5000.0; // conversion en mV
celsius = millivolts/10; // conversion en Celsius
// en début de programme
const int inLum = 0 ; // broche entrée capteur
// dans la boucle principale
valeur = analogRead(inLum) // lit la valeur (entre 0 et 1023)
Remarques :