Formations:Arduino:Initiation

From Electrolab
Revision as of 10:36, 28 April 2016 by Clément (Talk | contribs)

Jump to: navigation, search


Formation Arduino: initiation

Arduino, la célèbre carte à microcontrolleur, rend accessible la bidouille électronique dite embarquée: capteurs, actionneurs, code. Dans cette formation, nous allons découvrir ses capacités (entrées, sorties, communication) en réalisant plusieurs petits défis et montages sympa!

Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers Arduino.

Informations pratiques

  • Durée: 3h voire plus
  • Public visé: tous les membres, niveau débutant en programmation/électronique/Arduino

Formations liées

  • Formations suivantes:
    • Mon premier projet Arduino

Matériel requis

Il est indispensable d'avoir un ordinateur portable, et d'installer l'environnement de développement Arduino avant la formation pour gagner du temps. Voir (lien installation IDE).

Les exemples et exercices de cette page exploitent le contenu du kit de démarrage Arduino sauce Electrolab. Celui-ci contient:

  • Arduino Nano + cable USB
  • breadboard pour prototypage et cables male/male et femelle/femelle
  • potentiomètre & bouton poussoir (joystick)
  • leds rouge, verte, jaune, blanche, bleue, RGB et résistances 330 ohm
  • photorésistance & thermistance + set de résistances adaptées (2x1k, 2x10k, 2x100k)
  • micro-servomoteur, buzzer

Il est possible d'utiliser du matériel du lab (ordinateur portable, cartes arduino & accessoires), ou de vous équiper vous même.

Installation IDE

A déplacer au bon endroit/page de référence en la matiere:

Ressources additionnelles

Pour se fournir en matériel:

  • il y a un certain nombre de choses en vente à l'Electrolab directement, et notamment un kit de découverte Arduino parfaitement calé sur le déroulé de cette formation
  • de nombreuses enseignes vendent du matériel lié à arduino: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc

A propos d'Arduino

A propos de la programmation

A propos de l'electronique

Contenu détaillé

Cette formation est prevue pour être animée au lab. Il est envisageable de suivre le plan en autoformation (mais pour l'instant, cette page nécessite d'être étoffée). Le slide-pack est en cours de creation et sera mis à disposition ici prochainement.

Introduction

L'objectif de cette formation est de vous faire découvrir les microcontroleurs et leur mise en oeuvre, en se servant d'Arduino. Aucune connaissance particulière n'est requise pour pouvoir suivre la formation: nous allons voir progressivement tous les aspects nécessaires pour découvrir sereinement cet univers. Bien évidemment, si vous souhaitez approfondir ces points préalables, il est encouragé de participer aux formations correspondantes.


Microcontroleurs

  • Qu'est-ce qu'un microcontroleur?

Un microcontrôleur est un type de puce électronique très répandu, qui peut être compris comme un petit ordinateur tout intégré: processeur, mémoire, et périphériques sont contenus dans une seule puce électronique. Ce bidule est capable d'interagir avec le monde réel: mesurer des grandeurs physiques à l'aide de capteurs, et agir sur le monde physique en pilotant des actionneurs. Entre les deux (les entrées et les sorties), le processeur central exécute un programme écrit par vous ou quelqu'un d'autre, et a par conséquent un comportement choisi.

TODO: picture d'un chip au centre d'une carte.

  • A quoi ca sert/ou ca sert?

A plein de choses: interfacer des capteurs et actionneurs de tous types et décider/décrire le comportement (en écrivant un programme...) permet de réaliser plein de choses cool. Par exemple, une machine à laver, mais aussi une voiture, un ascenseur, bref, un très grand nombre d'objets du quotidien utilisent un microcontrôleur pour fonctionner. On peut imaginer celui-ci comme le cerveau de l'objet en question.

TODO: picture synoptique système d'un objet courant simple, avec visu entrées, sorties, algorithme

Par exemple: {système quelconque avec asservissement ou FSM, genre controleur de machine à laver? ou d'ascenceur?}


  • Comment on s'en sert?
    • Conception système: en premier lieu, il faut réfléchir à ce que l'on cherche à faire, et l'expliciter: de quelles entrées va-t-on se servir? de quelles sorties? Quel comportement souhaite-on obtenir de la part du système?
    • Réalisation matériel: une fois que tout est clair, on va relier les capteurs et actionneurs choisis à la carte électronique de commande. Il peut être pertinent de séparer clairement les différents modules, et de s'attaquer d'abord à tel capteur, vérifier que tout est OK, puis à tel actionneur.
    • Écriture du logiciel: quand on a câblé le matériel, on peut s'attaquer au logiciel: il est probablement bienvenu là encore de travailler petit bout par petit bout: diviser pour mieux régner!
    • Tests, correctifs & modifications: rien ne marche jamais du premier coup...


  • Quelles sont les possibilités de la carte Arduino qu'on utilise?

Outre le processeur central (qui va exécuter le programme qu'on écrit) et la mémoire (flash, pour stockage des données même sans alimentation, et RAM, pour les valeurs de travail), le microcontrôleur présent sur la carte Arduino qu'on utilise a plusieurs tours dans son sac.

Une grosse dizaine d'entrées dites "tout ou rien", ou numérique: le microcontrôleur peut voir la présence ou l'"absence" de tension, à des niveaux définis précisément: on parle d'état haut et d'état bas, soit 0 volt ou 5 volt entre la broche concernée, et la masse du microcontrôleur.

Ces broches peuvent également être configurées en sorties: ici, c'est le processeur (et donc notre programme) qui va imposer le niveau de tension, haut ou bas (eg 0v ou 5v). Attention par contre à la limite de puissance! la puce ne sait pas fournir un courant supérieur à 20mA par broche..

Entrées de mesure de tension (entre 0 et 5v): le microcontrôleur qu'on utilise dispose d'un périphérique bien pratique: le convertisseur analogique numérique, ou ADC (sigle anglais). Il permet de convertir une tension (entre 0v et 5v) sur une broche spécifique (6 disponibles) en une valeur entre 0 et 1023. Par exemple, s'il y a une tension de 2.5v sur une entrée ADC, le processeur lira la valeur 512 sur cette broche (1023*2.5/5).

Pour différentes raisons, il n'y a pas vraiment de possibilité de générer une tension autre que 0v ou 5v... mais pas de panique, il y a plusieurs astuces pour obtenir ce résultat !

Le microcontroleur en question contient également le nécessaire pour communiquer avec un ordinateur. Il contient également tout un tas d'autres périphériques & bidules plus sophistiqués, qu'on verra ultérieurement...

Concrètement: on utilise le logiciel fourni avec Arduino pour écrire notre programme, puis le compiler en un exécutable (c'est à dire, transformer le langage -presque- intelligible par un humain, en un langage que le processeur peut utiliser) et le charger dans la mémoire de la carte, grâce à un cable usb.


Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.

image d'une Nano


le pinout Arduino Nano

L'univers Arduino

Arduino a été pensé pour des étudiants designers, artistes... c'est à dire pas des specialists ou experts en électronique/programmation, pour qu'ils puissant malgré tout bidouiller des trucs super avec des microcontrolleurs. Ainsi, "facile à prendre en main" est tout en haut des objectifs d'Arduino. Comme on va le voir, c'est plutôt une réussite!

Par rapport à plein de cartes qui existaient auparavant, les gens d'Arduino ont fait plusieurs trucs géniaux:

  • Opensource: Ils se sont basés sur des outils existants, et ont eux aussi publié l'intégralité de ce qu'ils ont développé. Comme pour le libre en général, cela permet à tout un chacun de mieux comprendre comment cela fonctionne, et d'améliorer les outils existants.
  • Pas cher: Ils voulaient que la carte coute le prix d'un restaurant max, pour que les gens n'aient pas peur de la griller, et surtout, qu'ils puissent se l'acheter et jouer avec! Initialement vendue aux alentours de 20€, on trouve désormais des cartes clone pour quelques euros.
  • Pas un gadget/outil uniquement pédagogique: ils ont conçu une interface abordable, des raccourcis dans le langage de programmation, et une carte électronique robuste. MAIS ils l'ont fait en partant des "vrais" outils des pros, les rendant simplement plus accessibles au plus grand nombre. Cela permet, une fois les premiers pas effectués, de lever le capot et mettre les mains dans le cambouis si on le souhaite.

Tout cela a super bien fonctionné, et un nombre grandissant de gens se sont mis à s'en servir, à contribuer des ameliorations, des projets, des modules complémentaires... aujourd'hui la communauté est très puissante, et florissante. On trouve un nombre très important de capteurs, actionneurs, et exemples de code et de projets qui utilisent Arduino, ce qui simplifie grandement la réalisation de projets.

Les outils & le matériel

Nous allons découvrir chacun des éléments du kit de découverte Arduino.

TODO: pictures de partout.

Breadboard

  • Décrire comment marche une breadboard
  • Mises en garde/comment on fait un circuit

Arduino Nano

Préliminaires

Notions d'électronique et d'informatique

Pendant cette formation, nous allons manipuler:

  • des notions d'électronique :
    • électricité, tension/courant
    • circuit électrique, schémas et modèle
  • des notions d'informatique :
    • qu'est-ce que c'est qu'un programme? langage de programmation.
    • sémantique du langage et mots clés spécifiques Arduino.
    • étapes de travail: conception, écriture, compilation, tests & correctifs.

Vous pouvez regarder les formations sur ces sujets. Dans tous les cas, pas besoin d'être un expert: n'hésitez pas à poser des questions en cours de route - y compris, voire surtout à vos voisins.


Installation des logiciels

Installation/verification de l'IDE + du driver.

TODO: pictures de partout.

  • Installation pas à pas de l'IDE
  • Installation pas à pas du driver

Utiliser Arduino: l'IDE

  • menus (choix de carte/port, exemples)
  • boutons upload & terminal
  • fenêtre d'édition du programme

Sorties

On va voir par l'exemple ce que peut faire la carte coté sorties. Et pour ca, on va commencer avec le plus simple: allumer et éteindre une petite Led, de différentes manières.

Premier contact: l'exemple "Blink"

Manipulation

On va se servir de l'exemple de code "Blink", qui se trouve dans le menu Fichiers/Exemples/basics.

Il n'y a pas besoin de câbler un circuit et des composants : tout le nécessaire se trouve déjà sur la carte !

Une fois le fichier ouvert, cliquez sur le bouton "upload" pour compiler le programme, et le charger dans la mémoire du microcontroleur. Résultat: la LED L, reliée à la pin D13, clignote.

TODO: pictures.

Cette manipulation simple représente le B.A.BA de l'utilisation de microcontroleurs: bravo, vous venez de faire votre premier pas :)

Analyse

Essayons maintenant de comprendre ce qu'il se passe. Le schema utilisé est le suivant:

TODO: picture schematic sortie arduino resistance led.

Regardons maintenant notre programme:

  • la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis. Ici, on indique que la pin 13 est une sortie
  • la fonction loop() est ensuite exécutée en boucle. Elle contient quatre instructions:
    • on allume la led, en mettant la sortie 13 à l'état haut
    • on attend 1000 millisecondes, soit une seconde
    • on éteint la led, en mettant la sortie 13 à l'état bas
    • on attend 1000 millisecondes, soit une seconde

Défi 1: changer la vitesse de clignottement

Question: Comment on fait pour changer la vitesse à laquelle clignote la led ?

Objectifs:

  • Vérifier compréhension des principes du code
  • Passage immédiat à l'action, interaction immédiate avec le bidule.

Réponse: {masqué!}

  • en changeant la valeur 1000, on modifie le temps d'attente après avoir allumé ou éteint la led. Par exemple:
    • en mettant 200 et 200, la led clignote 5 fois plus vite
    • en mettant 2000 et 2000, la led clignote 2 fois plus lentement
    • en mettant 500 et 1500, la led clignote à la même vitesse, mais est allumée moins longtemps

Défi 2: SOS morse

Question: Comment on fait pour faire clignoter des motifs plus compliqué? Par exemple, le classique "SOS" en morse: ...---... ou encore trois flash courts, trois longs, trois courts.

Objectif: Ecrire un peu plus de code, du code plus sophistiqué.


Réponses:

  • diversité d'approches, de stratégies:
    • on peut faire de simples copier coller des 4 lignes de l'exemple de départ
    • utiliser des fonctions: créer une fonction flash_court() et une fonction flash-long(), par exemple
  • paramétrisation: le temps d'allumage peut être écrit "en dur" ou bien dans une variable, dont la valeur est facile à modifier à un seul endroit: const int duree_flash_court = 200; const int duree_flash_long = 600;


Questions subsidiaires:

  • comment faire varier la vitesse du morse? Réponse: il est infiniment plus pratique d'avoir un code paramétré que des valeurs "en dur"
  • comment changer le message qu'on envoit? Réponse: probablement en créant des fonctions flash_court, flash_long, puis des fonctions affiche_a(), affiche_b(), ou bien affiche(char c).

En bref: même sur un exemple simple, bien structurer son programme et anticiper ce à quoi il va pouvoir servir est important.

Défi 3: ultra rapide

Question: Il se passe quoi si on fait clignoter suuuper vite?

Objectif: découvrir la notion de PWM (Pulse Width Modulation).

Réponse: du fait de la persistence rétinienne, on n'arrive plus à distinguer les flashs indépendants, et on perçoit à la place une intensité lumineuse "moyenne", plus faible qu'un éclairement maximal.

Question: ajuster la vitesse de cliognottement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.

Réponse: environ 50Hz, soit 50 clignottements par seconde.

Question: ca veut dire quoi, super vite, pour le microcontroleur?

Réponse: il est cadencé à 16MHz, donc, grosso modo, fait 16 millions de choses par seconde! Or, au delà de 50 clignotements par seconde, l'oeil humain n'arrive plus vraiment à les distinguer.

Question: il se passe quoi quand on a des valeurs de delay différentes ?

Réponse: notion de rapport cyclique (c'est à dire rapport entre durée allumé et durée éteint) et fréquence (c'est à dire le nombre de fois par seconde que la led s'allume/s'éteint). Cela permet de modifier la valeur moyenne perçue à l'oeil. Même si le microcontroleur n'a pas de moyen direct de générer une valeur analogique (c'est à dire, pas seulement "marche" ou "arret", mais aussi des valeurs intermédiaires), avec l'astuce de la PWM, on peut obtenir un résultat équivalent.

TODO: pictures pour l'explication PWM/rapport cyclique, etc

PWM et sortie analogique

La PWM, pour Pulse Width Modulation, est une astuce pour simuler une sortie analogique (c'est à dire valeur quelconque entre 0v ou 5v, au lieu d'exclusivement 0v ou 5v pour une valeur digitale).

TODO: picture Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.

Il existe d'autres techniques, mais celle ci est la plus pratique/simple.

Défi : générer une sortie différente de 0 ou 5

dit autrement: proposer une implémentation soft de la fonction analogWrite.

Défi : exemple Fade et fonction analogWrite

voir une modif simple de fade, par exemple: led RGB.

Micro projet: feu tricolore

A ce stade, on est en mesure de concevoir et realiser un feu tricolore, en cablant les LED rouge, verte, et jaune.

TODO: detailler les bonus avec des schemas, exemples de code, etc...

Entrées

Pour réellement faire plein de choses intéressantes avec un microcontroleur, on a besoin de savoir mesurer des trucs dans le monde. Commençons par le plus simple: un bête interrupteur marche/arrêt.

Entrée digitale

Remarque préliminaire: quel exemple utiliser? en créer un avec internal pullup?

  • on veut un exemple genre bouton ON/OFF pour la led (eg appui <=> allumé)
  • Exemple Button, mais utilise une pulldown... a voir: le code est plus clair (eg logique appui<->true), MAIS on peut pas utiliser l'internal pullup.
  • C'est pas mal de préciser le principe de pullup/down - et la nécessité de mettre une résistance, mais compliqué à saisir en initiation.


  • découverte de l'objet: joystick/bouton
  • on fait le montage! (boutonA-résistance-GND boutonB-pin)
  • upload code
  • demo/test.
  • analyse schematic (eg entrée arduino pushbutton ; pullup?).
  • analyse code (reference sur le site Arduino)

Version alternative: utiliser une internal pullup, et donc une logique inversee.

défi 1: changer le fonctionnement

Qui a dit que le bouton devait faire X plutot qu'autre chose? Nous, avec le code! Comment changer vers un mode toggle (eg appui veut dire changer d'état) ?

En fait, il y a besoin de détailler un peu comment on va faire le code:

  • Lire l'entrée
  • prendre des décisions
  • appliquer les sorties.

Exemple (désolé pour la mise en page) :

int buttonState = HIGH; int buttonState_old = HIGH; int ledState = HIGH;

void setup() { 

pinMode(button_pin, INPUT_PULLUP);
pinMode(led_pin, OUTPUT);

}

void loop() { 

 buttonState = digitalRead(buttonState);  // on lit l'entrée
 if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?
   if(ledState == HIGH) {  //la led était allumée, on l'éteint
     digitalWrite(led_pin, LOW);
     ledState = LOW;
   }
   else {
     digitalWrite(led_pin, HIGH);
     ledState = HIGH;
   }
 }

 delay(100); // permet de faire un debounce

}

défi 2: menu

Comment on peut faire "sentir" à la carte un peu plus que juste "marche/arret" ? Par exemple, en comptant le nombre de fois ou on appuie, ou en différenciant les appuis longs et appuis courts.

Exemple d'interface "avancée":

  • défi 2a: compter le nombre d'appuis successifs
  • défi 2b: différencier les appuis longs ou courts

En fonction de cela:

  • toggle sur la led rouge, verte ou bleue selon si on fait un, deux ou trois appuis.
  • changer l'intensité d'allumage d'une LED: court veut dire plus fort, long veut dire moins fort.


Attention, piège du bounce (ou rebond, en francais). Lorsqu'on appuie sur le bouton, la lamelle de metal qui fait contact rebondit plusieurs fois (pendant 1/100e de seconde) avant de se stabiliser. Cela n'a pas d'importance si on se sert de cette information pour allumer ou éteindre la led, parce que l'oeil ne s'en rend pas compte. Par contre, lorsqu'on compte les changements d'état, cela risque de poser probleme! En effet, le microcontroleur, qui est rapide (16 millions d'opérations par seconde!) a amplement le temps d'observer et de compter chacun de ces rebonds, faussant complètement notre application.


La mesure preventive correspondante est appellee "debouncing" ou anti-rebonds. C'est quoi le debouncing? Il s'agit de s'assurer que la transition vue par le microcontroleur est "stable", c'est à dire qu'on va tenter d'éliminer les transitions dues aux rebonds.

Comment faire? Il y a plusieurs techniques. Par exemple, on peut ne prendre en compte les transitions seulement après une période choisie de stabilité: on regarde toutes les 50ms l'état de l'entrée, et seulement lorsque trois mesures successives donnent la meme valeur, on prend en compte cette nouvelle valeur.


TODO: ajouter picture pour comprendre le debounce.


Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection


Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:

  • Entrée: appui(s) bouton
  • Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different
  • Sortie: allumer ou éteindre une LED

Voyons maintenant des entrées/sorties encore plus cool !

Potentiomètre et Analog in

Exemple de code potard vers fade.

  • on fait le montage
  • upload code
  • demo/test.
  • "analyse" schematic (eg entrée arduino analog potard).
  • analyse code

=> OK! On peut mesurer des trucs mieux que juste marche/arret.


Pratiquement l'exemple https://www.arduino.cc/en/Tutorial/AnalogInput sauf que nous on connait déjà les PWM.

Bonus

  • défi: reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).
  • défi: piloter la RGB de facon marrante (par exemple, intensité d'éclairage, ou balance de couleur, ou vitesse de defilement de toutes les couleurs...).
  • défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)

Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".

Communication

Maintenant qu'on sait piloter des bidules et en mesurer d'autres... on aurait bien envie de pouvoir communiquer avec l'ordinateur. Ca tombe bien, c'est possible (c'est d'ailleurs ce qu'on fait quand on charge notre programme sur la carte!), avec le module UART.

Communication Arduino -> PC

  • On reprend notre montage avec le potard, et on charge un autre exemple de code:analogin serial out
  • On lance le moniteur série
  • analyse du schema: ca, c'est déjà bon. Remarque: avec un montage donné, on peut faire différents codes, selon ce qu'on veut faire. Y compris, des codes tres différents!
  • analyse du code: utiliser le module HW de communication série, qui permet de parler au PC, et envoyer des infos.

défi 1 : afficher autre chose que la valeur brute!

  • Par exemple, un coffre fort? Eg si deux potards sont à la bonne valeur (voire, une suite de positions), afficher un mot de passé/allumer une led. Ou trouver exemple/défi plus marrant...
  • Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable. Principe de l'hysteresis.
  • Exemple: se servir de la sortie UART pour "debugger": reprendre l'exemple du bouton, et tenter de caractériser le phénomène de rebond/ajuster notre debouncing. Remarque: on pourrait aussi plus proprement utiliser un oscilloscope...

Communication PC -> Arduino

exemple a creer:pilotage kbd vers allume/eteindre led.

  • pas de montage... on utilise la led sur la carte reliée à la PIN13
  • code à upload... et on lance le terminal série ; on envoit des caractères et on voit.
  • Analyse du code, pour comprendre ce qui s'est passé


byte inByte;

void setup() { 

 Serial.begin(9600);
 pinMode(13, OUTPUT);

}

void loop() { 

 if(Serial.available()>0) {
   inByte = Serial.read();
   switch(inByte) {
     case 'a':
       digitalWrite(13, HIGH);
       break;
     case 'e':
       digitalWrite(13, LOW);
       break;
   }
 }

}

défi 2 : ajouter des fonctions

  • exemple: pilotage RGB
  • exemple: valeurs/paramètres de fade
  • exemple: clignottements différents
  • exemple: pilotage de notre feu tricolore, voire envoi de commandes spéciales (modifier la durée de tel ou tel feu, changement de mode de fonctionnement...)

bonus

  • exemple: Terminal morse (avec potard pour vitesse)

Pour aller plus loin

On sait maintenant gérer des entrées, des sorties, communiquer avec le PC... mais on a que des leds, des boutons et des potards. Heureusement, il y a plein d'autres capteurs/actionneurs plus funky avec lesquels on peut interagir.

Autres outputs

Il y a plein de types d'actionneurs différents, on va en regarder seulement deux très simples à mettre en oeuvre: petit buzzer et petit moteur de modélisme.

Souvent, piloter ces sorties est plus complexe que simplement sortie MARCHE ou ARRET ; heureusement, il y a plein de librairies (eg, de bouts de code tout faits) à la rescousse pour nous!

output buzzer

  • schema
  • code example: tone
  • defis/applis marrantes... laissons libre court à l'imagination. On pourrait avoir le terminal Morse en audio plutot que sur la led. Ou faire un synthétiseur/thérémine avec le joystick

output servo

  • schema
  • code example: swipe/knob
  • defis/applis marrantes: A voir...


Autres capteurs

Il y a une infinite de capteurs différents... on va regarder seulement deux très simples: lumière et temperature.

Peut importe comment le capteur fonctionne physiquement, l'arduino ne sait que mesurer des tensions ou voir l'état (MARCHE/ARRET) d'une de ses pattes. Bon, elle sait aussi communiquer avec un PC - ou un autre microcontroleur. Ce qui peut etre le cas avec un capteur sophistiqué (eg, il inclut un petit microcontroleur, et renvoit directement des valeurs numériques).

Il y a plusieurs capteurs qui se comportment comme des resistances variables: pour les capteurs de lumiere et de temperature qu'on utilize, c'est le cas. On va donc pouvoir/devoir faire un "faux" potentiometre (on dit pont diviseur de tension, car c'est un montage/une forme/une topologie ultra classique), qui va permettre mesurer la variation de résistance.

IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe. IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.

Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien. La valeur optimale est la "moyenne log entre valeur min et max de la résistance variable", parce que cela permet d'avoir la plus grande dynamique. C'est à dire: il faut prendre une valeur entre le max et le min de résistance pour avoir la plus grande plage de variation de la tension mesurée. Par exemple, si le capteur change de 100 à 10000 ohm selon qu'il a beaucoup ou très peu (de lumière/de chaleur), on veut mettre une résistance de 1000 ohms.

Remarque: il faut faire attention aussi au courant consommé : ici, 1100 ohms au minimum sur l'alimentation 5v, ca reste OK, car le courant débité sera de 5V/1100ohm = 0.0045A, inférieur à la limite de 0.02A

capteur lumiere

  • schema: pont diviseur de tension. Expérimentation pour trouver la valeur optimale de résistance
  • code example: on peut reprendre tous ceux où on avait un potentiometer avant...
  • defis/applis marrantes

capteur température

  • schema: pont diviseur de tension. Expérimentation pour trouver la valeur optimale de résistance
  • code example: on peut reprendre tous ceux où on avait un potentiometer avant...
  • defis/applis marrantes

Conclusion

Cette formation a permis de faire nos premiers pas avec un microcontroleur, en utilisant Arduino:

  • sorties (digitales et analogiques),
  • entrées
  • communications avec le PC
  • capteurs et actionneurs sympa!

Au passage, on a fait des petits bouts de schema, écrit du code... bref, fait pas mal de choses!

On a pu realizer des defis/bonus, et en inventer d'autres... d'ailleurs, c'est un peu comme ca que ca marche quand on veut faire un système/projet quelconque! On commence par examiner chacun des petits bouts, avant d'assembler les pieces du puzzle.

la suite

  • Assister à la formation "mon premier petit projet Arduino". L'idée est justement d'utiliser d'autres modules capteurs/actionneurs pour realiser un petit projet qui vous intéresse (un robot? un automate pour une serre? un jeu?)

=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?

  • Améliorer votre comprehension des microcontroleurs, de l'électronique numérique, de l'informatique embarquée, ...

=> Qu'est ce que vous voulez apprendre de plus/approfondir?

  • notes/laissés en exercices:
    • grapher les caractéristiques capteur de température, de lumière.
    • faire marcher le buzzer et le servomoteur SANS appel à la librairie
    • -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".
  • projets:
    • bouilloire d'eau avec asservissement température
    • clignotants vélo+système d'éclairage "simple"
    • ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)

retours sur la formation

  • Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?
  • Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?

A vous la parole: remplissez la fiche d'évaluation. Rangeons le materiel et la salle pour les suivants!

Fourre tout sur la suite

Quelques notes sur les sujets qu'on peut avoir envie d'aborder...

Dans la série purement SW... Fonctions additionnelles:

  • millis, micros ; structure if(time_current>time_last+time_period)
  • attachinterrupt
  • switch case/FSM
  • asservissement

Autres topics SW:

  • RT OS (eg scheduler, mecanismes usuels)
  • bootloader
  • USB (sur 32u4)
  • lib writing/packaging
  • real debugging (eg debugwire)
  • real toolchain (eg avrstudio, eclipse)

Autres topics HW:

  • fork board
Retrieved from "https://wiki.electrolab.fr/index.php?title=Formations:Arduino:Initiation&oldid=18418"