-
ARDUINO > Présentation
- Microcontrôleur avec des entrée/sortie capable de mesurer des tensions.
- Génère des tensions (avec les voies PWM qui peuvent être utilisées en conversion numérique analogique)
- Effectue des traitements informatiques et mémoriser des données. Programmable en C.
Utilisation : charger sur le PC l’IDE gratuit pour le programmer, brancher l’Arduino en USB du PC, écrire le programme (sketch), le charger dans l’Arduino et le lancer.
On peut empiler des cartes d’interfaces sur la carte mère (le piggy back) et augmenter ses fonctions. On appelle ces cartes des shields. Il existe un shield Ethernet, que je vais utiliser pour son lecteur de carte SD, un shield Wi-Fi, un shield GSM, un shield pour contrôler des moteurs, etc.Convertisseur Analogique Numérique 10 bits 6 voies
14 broches d’E/S dont 6 PWM (Pulse Width Modulation) avec courant de sortie de 40 mA, avec une limite à 200 mA pour l’ensemble des sorties analogiques.
Alimentation par port USB B ou par adaptateur 7 à 12 V.
bootloader : programme qui gére la communication avec le PC sur le bus USB et le chargement des programmes depuis le PC.
Sites de référence et tutorials pour la programmation.
- site officiel d’Arduino et ne vous plaignez pas vous cultiverez aussi votre anglais ! Pour apprendre à programmer l’Arduino :
- Le tutorial officiel d’Arduino
- Une bonne introduction en français
EXEMPLE : Tester une pile
Étudier la décharge d’une pile saline qui fonctionne par oxydoréduction du zinc et du dioxyde de manganèse.
Pile plate 3R12, composée de 3 cellules Zn/MnO2 en série, qui délivre chacune une fem de 1,5V. Ma pile délivre donc 4,5 V.
Attention à ne pas utiliser une pile alcaline : sa capacité est bien plus grande.La mesure de la décharge
Décharge lente d’une pile dans une charge résistive composée d’une résistance R et d’une diode LED témoin pour animer un peu la manip. Le but est de tracer la courbe U= f(t), U étant la tension aux bornes de la pile. Le courant de décharge sera relativement faible, 120 mA environ, suffisant pour que l’expérience ne dure pas trop longtemps, mais pas assez fort pour griller mes résistances dont la puissance admissible ne dépasse pas 0,5 W.
Que faut-il mesurer ?
L’Arduino sait mesurer une tension comprise entre 0 et 5V, avec une précision égale à 5/2^10 V, soit environ 4,8 mV. La pile choisie présente une f.e.m de 4,5 V, ce qui est compatible avec la plage en tension d’entrée de l’Arduino, sans montage d’adaptation en tension, comme des ponts diviseurs de tension ou autre diode Zener.
Comment mesurer ?
La pile met une journée pour se décharger. Une mesure toutes les 2 min produit 720 mesures en une journée, ce qui est très raisonnable pour tracer une courbe.
Quand finir la mesure
Fixer a tension VMin à partir de laquelle nous décidons que la pile est déchargée, d’après la physique de la décharge. Et l’on indique au programme qu’il doit s’arrêter lorsque la tension lue est inférieure à cette tension VMIn. Mais la logique de la programmation de l’Arduino complique un peu les choses. Nous verrons plus loin que sa routine principale, la routine loop(), boucle indéfiniment comme son nom l’indique. Il n’y a pas de moyen d’en sortir sinon de faire un reset. Astuce : arrêter la manip lorsque la LED rouge témoin de décharge sera éteinte, c’est à dire lorsque la tension à ses bornes sera inférieure à sa tension de seuil, comprise entre 1,6 V et 2 V pour une LED rouge.
Le montage expérimental
Le principe
Circuit composé d’une pile, une résistance de charge, et un groupe composé d’une LED rouge et d’une résistance limitatrice de courant (une LED fonctionne avec un courant d’environ 20 mA).
Vous remarquez aussi un groupe de 5 résistances de 220 ohm montées en parallèle : Pour obtenir un temps de décharge de l’ordre de la journée, sachant que la capacité standard d’une pile saline est en principe de 2700 mAh, il faut faire circuler un courant de l’ordre de 110 mA. J’ai déjà un courant de 20 mA qui circule dans la branche de la LED. Il me faut donc un courant d’environ 90 mA qui circule dans la résistance.
Je sais d’autre part que mes résistances ne supportent qu’une puissance max de 0,5 W, ce qui, d’après la formule P = UI (courant continu), me donne un courant max de I = P/U, soit I = 0,5/4,5 soit environ I = 100 mA. Nous faisons ici de l’électronique, donc vive les ordres de grandeur, pas besoin de sortir la calculette !
Donc, pas de pb pour la valeur du courant, environ 100 mA. Pour calculer la résistance correspondante, j’applique bien sur la célèbre loi d’Ohm, soit U = RI, ce qui me donne R = U/I soit R = 4,5/0,1 = 45 ohm.
Comme il n’y a que des 220 ohm, on applique la règle de calcul des résistances en parallèle ! Pour obtenir environ 45 ohm, j’utilise 5 résistances de 220 en parallèle.Programmer l’Arduino
Le principe du programme
L’algorithme mis en œuvre sera très simple :
- Nous commencerons par initialiser les circuits d’acquisition et de stockage sur la carte SD de l’Arduino.
- Puis nous construirons une boucle d’acquisition qui déclenchera périodiquement, selon la période d’échantillonnage fixée ci-dessus, les opérations suivantes :-- Lecture de la tension aux bornes de la pile
-- Conversion de la donnée
-- Affichage sur l’écran de notre PC
-- Enregistrement du numéro de mesure et de la tension lue
Jusqu’à ce que la tension lue soit inférieure au seuil VMin.
Je vais donc enregistrer, pour chaque mesure, deux valeurs dans un fichier ASCI nommé Pile.txt, afin de pouvoir les traiter plus tard avec un autre programme. Chaque enregistrement du fichier se présentera ainsi:
NumMesure;ValeurMersure
Par exemple:
21;4.648
Le code du programme
En langage C, le code commence par la liste des headers à inclure. Nous n’en avons qu’un seul, le fichier SD.h qui comprend les ent-têtes de routines de gestion de la carte SD et de son lecteur.
Puis vient la liste des variables globales et des constantes. Arrêtons nous sur les constantes suivantes :const int Pile = 0; // la pile est branchée sur l'entrée analogique A0 const int LedVerte = 2; // la led verte est branchée sur la sortie 2 const int SDCard = 4; // broche de la SDCard sur le shield Ethernet const int SelectEther = 10; // broche de sélection du shield Ethernet
Il s’agit de la définition des différents ports du microcontrôleur. La broche 4 de l’Arduino commande le lecteur SD installé sur le shield Ethernet, lequel est adressé sur la broche 10.
Un programme Arduino est composé d’au moins deux routines de base : la routine
setup()et la routineloop().
setup()s’exécute une seule fois, au démarrage du programme ou à la mise sous tension de l’Arduino. Elle doit contenir le code d’initialisation de la carte et du process. Dans notre cas, il s’agit d’initialiser la carte SD. Puis,loop()boucle indéfiniment jusqu’à ce que Reset soit appuyé.loop() comprend quatre parties :
- La lecture de la tension sur l’entrée A0 et la construction de la donnée "tension" :ValeurCAN = analogRead(Pile); Tension = map(ValeurCAN, 0, Range, 0, TensionRef); Tension = Tension / 1000.0; dtostrf(Tension,5,3,sTension);
Le programme lit une valeur comprise entre 0 et 1023 sur la broche A0 du CAN, qu’il convient de convertir en tension. C’est le rôle de l’instruction map(). La constante TensionRef désigne la tension de référence de l’Arduino, fixée à 5 V. On peut aussi se priver de l’usage de map() en faisant une simple règle de trois, mais je trouve que l’usage de map() est plus propre. La tensoin calculée par map() est exprimée en millivolt, je la convertis en V en divisant pas 1000.0. Attention à exprimer 1000.0 en float !
La dernière instruction convertit la valeur float de la tension en une chaine de 5 caractères avec 3 chiffres après la virgule (ex: 4.876)- Le stockage des données, numéro de mesure et valeur de la tension lue, sur la carte SD et l’incrémentation du numéro de mesure :
Buffer = ""; Buffer = String(NumMesure,DEC) + ";" + String(sTension); SDFile = SD.open("Pile.txt", FILE_WRITE); // ouvre le fichier en écriture if (SDFile) { SDFile.println(Buffer); // écriture des données SDFile.close(); // fermeture du fichier } else { // Serial.println("Erreur a l'ouverture du fichier de donnees"); return; } // Incrémentation du compteur de mesure NumMesure++;
Vous noterez que je ferme le fichier de mesures après chaque écriture. C’est une habitude lorsqu’on fait de l’acquisition à faible fréquence. Si le dispositif se plante entre deux mesures, ce qui peut arriver, au moins nous ne perdrons pas les mesures déjà faites, ce qui serait probablement le cas si le fichier restait ouvert.
- Le clignotement de la LED, qui indique qu’une mesure vient d’être réalisée, et que le dispositif vit !
digitalWrite(LedVerte,LOW); delay(500); digitalWrite(LedVerte,HIGH);
Ces trois instructions permettent d’alimenter la LED verte pendant 500 ms puis de l’éteindre. Attention à l’inversion de logique BAS HAUT qui correspond au câblage. D’ailleurs, j’aurais pu mettre ces trois instructions dans une routine Blink(), par exemple, ça aurait été plus propre…
- La temporisation de mesure, ici une mesure toutes les deux minutes, et la condition de sortie (qui ne sert pas à grand chose !)
if (Tension >= TensionMin) delay(Tempo); // Temporisation entre deux mesures else { // Serial.println("Fin de la manipulation"); return; }
Rien à dire, sinon que la constante Tempo vaut 120 000 ms soit 2 minutes. Nous avons donc une mesure toutes les deux minutes.
Le code complet du programme DechargePile est disponible ici. Pour l’utiliser, vous devez le charger dans l’IDE d’Arduino puis dans l’Arduino après avoir vérifier sa syntaxe et sa bonne compilation.
Démarrer l’expérience
Pour lancer l’expérience, il faut:
- Mesurer avec un multimètre la tension à vide de la pile neuve. Noter la valeur de la tension lue.
- Brancher la pile sur le montage.
- Lancer le programme d’acquisition en le téléchargeant dans l’Arduino (la flèche vers la droite dans la barre d’outils de l’IDE).
- Lancer le moniteur série à partir du menu de l’IDE (Tools/Serial Monitor), si besoin . On verra que ce n’est pas forcément une bonne idée.
- Vérifier son bon fonctionnement en s’assurant que les tensions lues s’affichent sur l’écran, ou en vérifiant que la LED verte clignote toutes les deux minutes.
- Laisser le programme tourner !
Les premiers résultats de l’expérience
J’ai donc lancé l’expérience un après-midi à 16:10. Voilà à quoi ressemblait ma manip initiale :
Dans cette version initiale, la pile débitait uniquement dans la résistance limitatrice de courant de la diode, d’une valeur de 220 ohm, avec un courant de 20 mA… Je ne vous dis pas la durée de la manip, si je l’avais laissé aller au bout !
Vous notez que l’Arduino est relié à mon PC par un câble USB. D’abord, et surtout, pour l’alimenter électriquement. Et aussi, pour transférer les données à chaque mesure histoire de suivre la manip. Voilà à quoi ressemblait l’écran de mon PC.
A droite, la fenêtre de l’IDE et à gauche le moniteur série, qui affiche les valeurs de la tension au fur et à mesure de leur acquisition.
Mais attention à désactiver la mise en veille du PC. Quelques modifications au montage et au programme
- pour suivre le déroulement de la manip, une LED vert clignote (allumée pendant 500 ms) à chaque mesure.
- Alimenter l’Arduino indépendamment du PC. Chargeur d’iPod qui trainait dans un tiroir. Il délivre 0,85A sous 5 V.
Le montage modifié :
La tension à vide de la pile était de 5.002 V , mesurée au multimètre de laboratoire.
Analyse des résultats
Éjecter la carte SD de l’Arduino puis transférer le fichier Pile.tx (disponible ici, 13 Ko) dans le même répertoire que le script Python TracePile.
Pour tracer la courbe, un script Python disponible ici.
Read_Datalit séquentiellement le fichier, split chaque enregistrement (données séparées par un;) et stocke la valeur de mesure dans la listeLtension.
A noter la puissance du Python pour effectuer ces opérations, en particulier la méthode split sur la lignedef Read_Data(filename): datafile = open(filename,'r') Ltension = [] for line in datafile: data = line.split(";") tension = float(data[1]) Ltension.append(tension) datafile.close() Ltension