Difference between revisions of "Formations:Arduino:Initiation"

From Electrolab
Jump to: navigation, search
(→‎défi 2: SOS morse)
(→‎défi 3: ultra rapide)
Line 154: Line 154:
 
* persistence rétinienne
 
* persistence rétinienne
 
* rapport cyclique (eg temps allumé vs temps éteint) et fréquence (eg nombre de fois par seconde que la led s'allume/s'éteint)
 
* rapport cyclique (eg temps allumé vs temps éteint) et fréquence (eg nombre de fois par seconde que la led s'allume/s'éteint)
 +
* ca veut dire quoi, super vite, pour le microcontroleur? Eg, sa fréquence de fonctionnement, ordres de grandeurs, ...
  
 
=== PWM et sortie analogique ===
 
=== PWM et sortie analogique ===

Revision as of 18:58, 20 January 2016

Page en cours de creation...

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 defis et montages sympa!

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

Informations pratiques

  • Durée: 3h
  • Public visé: tous les membres (aucun prérequis particulier)

Formations liées

  • Prérequis: aucun, à part savoir lire.
  • Idéalement:
    • notions basiques d'électronique
    • notions basiques de programmation
  • Formations suivantes:
    • Mon premier projet Arduino
    • (autres formations à venir...)

Matériel requis

Il est indispensable d'avoir un ordinateur portable, et d'installer l'environnement Arduino (voir https://www.arduino.cc/en/Main/Software#) avant la formation pour gagner du temps. Notez également que les cartes que nous utilisons nécessitent le driver ch340 (https://www.google.fr/?q=ch340+driver)

Il est possible d'utiliser du materiel du lab (cartes arduino & accessoires), ou de vous équiper vous meme.

Ce que nous allons utiliser:

  • carte Arduino (Nano, mais autres versions OK) + cable usb
  • kit de démarrage sauce Electrolab:
    • breadboard, fils, potentiometre & bouton poussoir (joystick), leds + résistances 220 ohm.
    • micro-servomoteur, buzzer, photoresistance et thermistance + resistances adaptées.

Tout ce materiel est dispo dans le kit d'initiation Arduino de l'Electrolab, ainsi que dans la valise d'initiation Arduino, qui contient le materiel nécessaire pour 10 personnes.

Ressources additionnelles


  • how to electronique: resource à identifier... ou créer ; voir par exemple sur le wiki du lab
  • pour se fournir en matériel:
    • on a des trucs à dispo (et d'autres en vente) au lab
    • il y a plein de gens bien de ci de là (sparkfun, adafruit industries, lextronic, snootlab, etc etc etc etc)
  • ouvrages papier: à mon humble avis, "Arduino pour les nuls" est pas mal.

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 integre: processeur, mémoire, et périphériques sont intégrés dans une 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 donné. Par exemple: si le capteur de temperature montre qu'il fait trop chaud, démarrer le moteur du ventilateur.

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)

  • 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 peu tout objet du quotidien.

(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 realizer d'objet fonctionnel intéressant, mais plutôt s'intéresser aux fonctionnalités de base, 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?
    • Realisation 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 cable 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 executable (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, grace a un cable usb.

  • Concrètement, 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 meme 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 plus que 20mA par broche..

Entrées de mesure de tension (entre 0 et 5v): le microcontroleur qu'on utilize 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.

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: 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 bidouiller des trucs super avec des microcontrolleurs malgré cela. Ainsi, "facile à prendre en main" est tout en haut des objectifs d'Arduino... et comme on va le voir, c'est plutôt une réussite!


Par rapport à plein de modules pré-existants, 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é
  • 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!
  • Pas un gadget/outil pédagogique: ils ont conçu une interface abordable, des raccourcis dans le langage, et une carte électronique robuste. MAIS 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.

Comment on s'en sert?

  • Tour de presentation rapide du materiel dans le kit/la valise: carte + bread board, leds, capteurs, actionneurs.
  • Installation/verification de l'IDE + du driver.
  • Ecriture du programme (ou reprise d'un exemple existant), puis compilation/chargement (bouton upload)

Comme évoqué ci avant, on va manipuler à la fois des notions d'électronique (realisation de schemas électroniques, pilotage de capteurs et actionneurs, tension/courant, caractéristiques des composants, etc) et des notions d'informatique (conception d'un programme, écriture et compilation, tests & correctifs, ...). Pourtant, cette formation est sensée n'exiger aucun pré-requis!

L'approche retenue dans cette formation 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/surtout à vos voisins.

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.

Blink

  • upload
  • demo

=> check que environnement est OK. Include troubleshooting link.

  • "analyse" schematic (eg sortie arduino resistance led).
  • analyse code, comprehension IDE

défi 1: changer vitesse

Comment on fait pour changer la vitesse à laquelle ca clignotte?

Objectifs:

  • Vérifier comprehension des principes du code
  • Passage immediat à l'action/interaction immediate avec le bidule.

défi 2: SOS morse

Comment on fait pour faire clignoter des motifs plus compliqué?

Faire clignotter selon un motif plus compliqué, par exemple le cassique SOS en morse (...---... : trois flash courts, trois longs, trois courts).

Notions:

  • Ecrire un peu plus de code... voire de simples copier coller.
  • diversité d'approches/de strategies: fonctions?
  • paramétrisation: le temps d'allumage peut être écrit "en dur" ou bien une variable, dont la valeur est facile à modifier à un seul endroit.

défi 3: ultra rapide

Il se passe quoi si on fait clignoter suuuper vite?

Notions:

  • persistence rétinienne
  • rapport cyclique (eg temps allumé vs temps éteint) et fréquence (eg nombre de fois par seconde que la led s'allume/s'éteint)
  • ca veut dire quoi, super vite, pour le microcontroleur? Eg, sa fréquence de fonctionnement, ordres de grandeurs, ...

PWM et sortie analogique

=> PWM, astuce pour simuler une sortie analogique (eg entre les deux plutot que tout ou rien, 0 ou 5v.)

Ya d'autres techniques, mais celle ci est quand meme la plus pratique/simple.

Bonus

  • exemple fade
  • jouer avec une led RGB.
  • concevoir et realiser un feu tricolore

Entrées

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

Entrée digitale/Pas d'exemple existant? à créer

  • Remarque: on veut un exemple genre bouton ON/OFF pour la led (eg appui <=> allumé)
  • Exemple button, mais pulldown... a voir, le code est plus clair, MAIS on peut pas utilizer l'internal pullup. En meme temps, pas mal de préciser le principe de pullup/down... mais compliqué à saisir en initiation.
  • on fait le montage!
  • upload code
  • demo/test.
  • "analyse" schematic (eg entrée arduino pushbutton ; pullup?).
  • analyse code (reference sur le site Arduino)

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:

<code> 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 un peu sale... } </code>

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. (Attention, piège du bounce). => Probablement bidon... Bounce instead?

=> un peu galère, de compter les appuis bouton. => OK, on commence à avoir un système complet: input, traitement, output.


Exemple existant: https://www.arduino.cc/en/Tutorial/StateChangeDetection

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.
  • défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)

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: utilizer 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, afficher un mot de passé. Ou trouver exemple/défi plus marrant...
  • Par exemple, du "filtrage"


Communication PC -> Arduino

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

  • pas de montage... on utilize la led built in
  • 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 inBute;

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

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
  • defis/applis marrantes

output servo

  • schema
  • code example
  • defis/applis marrantes


Autres capteurs

Il y a une infinite de capteurs différents... on va regarder seulement deux très simple: 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).

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

Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... moyenne log entre valeur min et max de la résistance variable, pour avoir la plus grande dynamique. Par exemple, si le capteur change de 100 à 10000 ohm, on veut mettre une résistance de 1000 ohms. Attention aussi au courant consommé (eg, 1100 ohms au minimum sur l'alimentation 5v, ca reste OK).

capteur lumiere

  • schema
  • code example
  • defis/applis marrantes

capteur température

  • schema
  • code example
  • 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!

La suite (par exemple) :

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

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

  • Améliorer votre comprehension des microcontroleurs, de l'informatique embarquée (eg compréhension tech plus détaillée, modules HW/features avancés/uC différents/plus touffus, écrire du code de plus en plus complexe, ...)

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

  • Animer vous meme cette formation!

=> Critiquez la formation, appropriez vous le contenu.

A vous la parole (links pour feedback)

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