Difference between revisions of "Formations:Arduino:Initiation"

From Electrolab
Jump to: navigation, search
(→‎Ressources additionnelles)
(→‎Microcontroleurs)
Line 75: Line 75:
 
Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.
 
Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.
  
−
(TODO:picture de la board)
+
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg image d'une Nano]
  
 
* A quoi ca sert/ou ca sert?
 
* A quoi ca sert/ou ca sert?

Revision as of 15:45, 27 April 2016


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.


Microcontroleurs

  • Qu'est-ce qu'un microcontroleur?

Un microcontroleur 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 execute un programme écrit par vous ou quelqu'un d'autre, et a par consequent un comportement choisi. Par exemple: si le capteur de temperature montre qu'il fait trop chaud, démarrer le moteur du ventilateur. Le programme que l'on écrit va aller lire la valeur du capteur, comparer cela à un seuil donné, et si la condition est remplie, actioner le moteur du ventilateur.

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

image d'une Nano

  • A quoi ca sert/ou ca sert?

A plein de choses: interfacer des capteurs et actionneurs de tous types et decider/decrire le comportement (en écrivant un programme...) permet de realiser plein de choses cool. Par exemple, une machine à laver, mais aussi une voiture, un ascenceur, bref, un très grand nombre d'objets du quotidien utilisent un microcontroleur 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).

Dans le cadre de cette formation, on ne va pas vraiment réaliser un objet intéressant, mais plutôt s'intéresser aux fonctionnalités de base des microcontroleurs, et à la manière de concevoir un projet utilisant un microcontroleur. Ce sera à vous par la suite de realiser vos propres projets!

  • 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 materiel: 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, verifier que tout est OK, puis à tel actionneur.
    • Ecriture du logiciel: quand on a cablé le materiel, 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...

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.

  • Quelles sont les possibilitees de la carte Arduino qu'on utilise?

Outre le processeur central (qui va executer 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 microcontroleur present 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 microcontroleur peut voir la présence ou l'"absence" de tension, à des niveaux definis précisémment: on parle d'état haut et d'état bas, soit 0 volt ou 5 volt entre la broche concernée, et la masse du microcontroleur.

Ces broches peuvent également être configurees 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 microcontroleur 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...

(TODO: picture PINOUT Arduino)

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 materiel

Tour de presentation rapide du materiel dans le kit/la valise: carte + bread board, leds, capteurs, actionneurs.

TODO: pictures de partout.

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

Installation/verification de l'IDE + du driver.

TODO: pictures de partout.

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

Notions d'électronique et d'informatique

Pendant cette formation, nous allons manipuler:

  • des notions d'électronique : schémas électroniques, pilotage de capteurs et actionneurs, tension/courant, caractéristiques des composants, etc
  • des notions d'informatique : conception d'un programme, écriture et compilation, tests & correctifs, etc

Pourtant, cette formation est sensée n'exiger aucun pré-requis! L'approche retenue est en effet de découvrir les notions fondamentales au fur et à mesure qu'on en aura besoin: laissez vous guider, et n'hésitez pas à poser des questions en cours de route - y compris, voire surtout à vos voisins.

En attendant, voici quelques billes pour pouvoir se lancer. TODO: add liens vers des ressources pour acquérir les notions fondamentales + peut être un recap rapide de ce qu'il est indispensable?

Notions d'électronique

  • électricité, tension/courant
  • circuit électrique, schema/modélisation

Notions de programmation

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.

Premier contact: l'exemple "Blink"

Manipulation

On va se server de l'exemple de code "Blink", qui se trouve dans le menu XXX. L'avantage est qu'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 upload pour compiler le programme, et le charger dans la mémoire du microcontroleur. Résultat: la LED 13 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 :) Remarque: si quelque chose ne s'est pas passé comme prévu, consultez [TODO: troubleshooting link]

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: TODO: picture code Blink

TODO: analyse ligne à ligne de Blink: setup/loop, declaration variable 'led', etc etc.

Défi 1: changer la vitesse de clignottement

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

Objectifs:

  • Vérifier compréhension des principes du code... et donc des leviers requis pour obtenir le résultat attendu.
  • Passage immediat à l'action/interaction immediate avec le bidule.

Réponse: {masqué!}

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 strategies: utiliser des fonctions... voire faire de simples copier/coller.
  • paramétrisation: le temps d'allumage peut être écrit "en dur" ou bien une variable, dont la valeur est facile à modifier à un seul endroit.

Versions de code:

  • Copier coller versus fonctions
  • valeurs "en dur" versus valeurs paramétrables

Questions subsidiaires:

  • comment faire varier la vitesse du morse?
  • comment changer le message qu'on envoit?

Réponse:

  • 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éponses:

  • persistence rétinienne: on ne voit plus les flashs indépendants, mais une intensité lumineuse "moyenne".

Questions subsidiaires:

  • 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 clignottements par seconde, l'oeil humain n'arrive plus vraiment à les distinguer. Question: ajuster la vitesse de cliognottement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.
  • il se passe quoi quand on joue avec les valeurs de delays ? Réponse: notion de rapport cyclique (eg temps allumé vs temps éteint) et fréquence (eg 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 "sortir" 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 equivalent.

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 (eg entre les deux plutot que tout ou rien, 0 ou 5v.)

TODO: picture Schéma U/T pour visualizer 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'ailleurs, la fonction AnalogWrite (sur les pin avec un ~) permet de faire cela directement!

Bonus

  • Voir l'exemple de code "Fade", et l'utilisation de la fonction "analogWrite"
  • Jouer avec une led RGB pour faire plein de couleurs (penser au cablage des resistances, des sorties capables de faire analogWrite, c'est à dire avec '~')
  • Micro projet: 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=18414"