Difference between revisions of "Formations:Arduino:Initiation"

From Electrolab
Jump to: navigation, search
(la suite)
(Formation Arduino: initiation)
 
(47 intermediate revisions by one user not shown)
Line 1: Line 1:
 
[[Category:Formation | Initiation Arduino]]
 
[[Category:Formation | Initiation Arduino]]
__NOTOC__
+
 
 
= Formation Arduino: initiation =
 
= 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!
 
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.  
 
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers Arduino.  
 +
 +
Cette page, un peu dense O:-) rassemble plein d'infos et de pistes pour suivre cette formation. Un peu de patience, un jour tout sera proprement remis en forme et digeste... n'hésitez pas à apporter des corrections et modifications!
 +
 +
== TODO/meta ==
 +
* séparer/intégrer/linker les pages "autres" directement connexes: install IDE, contenu du kit découverte, item du distributeur, formations préliminaires (eg électronique & programmation), et peut être micro/miniprojets?
 +
* ajouter shitloads of pictures
 +
* ajouter le module spoileralert pour masquer les réponses...
 +
* schéma frizting
 +
* prettyprint sourcecode...
 +
* couper en n pages (pour les 3 troncs de contenu, les annexes?), voire préparer pour migration vers learn.electrolab.fr
  
 
== Informations pratiques ==
 
== Informations pratiques ==
* Durée: 3h
+
* Durée: 3h voire plus
* Public visé: tous les membres
+
* Public visé: tous les membres, niveau débutant en programmation/électronique/Arduino
  
 
== Formations liées ==
 
== Formations liées ==
 
*Prérequis: aucun, à part savoir lire.
 
*Prérequis: aucun, à part savoir lire.
 
* Idéalement:
 
* Idéalement:
** notions basiques d'électronique
+
** notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]
** notions basiques de programmation
+
** notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]
  
 
* Formations suivantes:
 
* Formations suivantes:
Line 20: Line 30:
  
 
== Matériel requis ==
 
== 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.
+
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 https://www.arduino.cc/en/Main/Software
  
  
Notez également que les cartes que nous utilisons nécessitent le driver ch340 (https://www.google.fr/?q=ch340+driver).  
+
Les exemples et exercices de cette page exploitent le contenu du kit de démarrage Arduino sauce Electrolab. Il est en vente au lab pour 30€, et plusieurs exemplaires sont disponibles en prêt pour suivre cette formation.
  
 +
Contenu :
 +
* Arduino Nano + cable USB
 +
* breadboard pour prototypage et cables male/male et femelle/femelle
 +
* potentiomètre et 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 materiel du lab (ordinateur portable, cartes arduino & accessoires), ou de vous équiper vous meme.
+
Attention, les cartes que nous employons nécessitent un pilote de périphérique spécifique ! Ce sont des clones made in China à vil prix.
  
Ce que nous allons utiliser:
+
=== Installation IDE ===
* carte Arduino (Nano, mais autres versions OK) + cable usb
+
A déplacer au bon endroit/page de référence en la matiere:
* kit de démarrage sauce Electrolab:
+
* voir https://www.arduino.cc/en/Main/Software#
** breadboard, fils, potentiometre & bouton poussoir (joystick), leds + résistances
+
* https://learn.sparkfun.com/tutorials/installing-arduino-ide à traduire
** micro-servomoteur, buzzer, photoresistance et thermistance + resistances adaptées.
+
* Notez également que les cartes que nous utilisons au lab nécessitent le driver ch340 (https://www.google.fr/?q=ch340+driver). Les tutoriels "officiels" Arduino ne marchent pas avec ces cartes : il faut impérativement installer le pilote correct pour votre système d'exploitation.
 
+
Tout ce materiel est disponible dans le kit d'initiation Arduino de l'Electrolab.
+
  
 
== Ressources additionnelles ==
 
== Ressources additionnelles ==
* documentation Arduino en ligne:
+
Pour se fournir en matériel:
** sur le site www.arduino.cc : [https://www.arduino.cc/en/Tutorial/HomePage tutoriels] et surtout [https://www.arduino.cc/en/Tutorial/BuiltInExamples exemples de code avec explications] ; voir aussi [https://www.arduino.cc/en/Reference/HomePage pour les elements du langage de programmation et les librairies], et [https://www.arduino.cc/en/Guide/HomePage la page équivalente à celle-ci] directement sur le site official (en moins bien, forcément ;)
+
* 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
** plein d'autres sites (voir par exemple les sites des vendeurs genre sparkfun, adafruit industries, ...).
+
* de nombreuses enseignes vendent du matériel lié à arduino: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc
** [http://eduscol.education.fr/sti/sites/eduscol.education.fr.sti/files/ressources/techniques/3846/3846-les-cles-de-la-carte-esplora.pdf doc sur esplora], sympa
+
** reference francophone: pas mal de choses bien ici: http://eskimon.fr/
+
 
+
* how to code:
+
** resource à identifier... ou créer
+
  
* how to electronique: resource à identifier... ou créer ; voir par exemple [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|sur le wiki du lab]]
+
=== A propos d'Arduino ===
 +
* sur le site www.arduino.cc : [https://www.arduino.cc/en/Tutorial/HomePage tutoriels] et surtout [https://www.arduino.cc/en/Tutorial/BuiltInExamples exemples de code avec explications]
 +
* [https://www.arduino.cc/en/Guide/HomePage la page équivalente à celle-ci] directement sur le site official (en moins bien, forcément ;)
 +
* [http://eduscol.education.fr/sti/sites/eduscol.education.fr.sti/files/ressources/techniques/3846/3846-les-cles-de-la-carte-esplora.pdf doc sur esplora], sympa
 +
* reference francophone: pas mal de choses bien ici: http://eskimon.fr/
 +
* explorez les sites des vendeurs de matériel type Sparkfun, Adafruit Industries, ...
 +
* ouvrages papier: à mon humble avis, "Arduino pour les nuls" est pas mal.
  
* pour se fournir en matériel:
+
=== A propos de la programmation ===
** on a des trucs à dispo (et d'autres en vente) au lab
+
* notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]
** il y a plein de gens bien de ci de là (sparkfun, adafruit industries, lextronic, snootlab, etc etc etc etc)
+
* voir [https://www.arduino.cc/en/Reference/HomePage les elements du langage de programmation et les librairies Arduino]
 
+
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique
* ouvrages papier: à mon humble avis, "Arduino pour les nuls" est pas mal.
+
* https://fr.wikiversity.org/wiki/Introduction_g%C3%A9n%C3%A9rale_%C3%A0_la_programmation
 +
* https://fr.wikiversity.org/wiki/Introduction_au_langage_C
  
Note: les schema & images sont réalisées avec http://fritzing.org
+
=== A propos de l'electronique ===
 +
* notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]
 +
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|sur le wiki du lab]]
 +
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique
 +
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectromagn%C3%A9tisme_et_%C3%A9lectricit%C3%A9
  
 
= Contenu détaillé =
 
= Contenu détaillé =
Line 62: Line 83:
  
 
== Introduction ==
 
== 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.
+
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.
  
 +
Dans le cadre de cette formation, on va s'intéresser aux fonctionnalités de base des microcontrôleurs, et à la manière de concevoir un projet utilisant un microcontrôleur. C'est un premier pas vers une grande diversité de projets !
  
=== Microcontroleurs ===
+
==== Préliminaires: notions d'électronique et d'informatique ====
* Qu'est-ce qu'un microcontroleur?
+
Pendant cette formation, nous allons manipuler:
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.
+
* 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 [https://www.arduino.cc/en/Reference/HomePage mots clés spécifiques Arduino].
 +
** étapes de travail: conception, écriture, compilation, tests & correctifs.
  
Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.
+
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.
  
(TODO:picture de la board)
 
  
* A quoi ca sert/ou ca sert?
+
=== Microcontrôleurs ===
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.
+
Pour en savoir plus, voici la page du fabricant de la puce au coeur de la carte qu'on va utiliser: http://www.atmel.com/devices/atmega328p.aspx
  
(TODO:picture synoptique système d'un objet courant simple, avec visu entrées, sorties, algorithme).
+
Par ailleurs, le document technique de référence (datasheet) de ce composant est intéressant à lire ou survoler: http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf
  
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!
+
https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR
  
* 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.
+
==== Qu'est-ce qu'un microcontrôleur? ====
 +
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.
  
* Quelles sont les possibilitees de la carte Arduino qu'on utilise?
+
TODO: picture d'un chip au centre d'une carte.
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.
+
==== Qu'est-ce qu'un microprocesseur ? ====
 +
En anglais: CPU, central processing unit: unité centrale de calcul. C'est le bidule au coeur d'un ordinateur, qui exécute des instructions correspondant à un programme. Ces instructions sont très simples. Par exemple :
 +
* ajouter la valeur 42 à la case mémoire #3
 +
* si la case mémoire #3 est nulle, aller exécuter l'instruction 2 cases plus bas dans la mémoire programme
 +
* sinon, exécuter celle 1 case plus bas dans la mémoire programme
  
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..
+
Pas facile de donner directement des ordres dans ce langage (l'assembleur), car il faut connaitre exactement ce que sait faire tel ou tel CPU, et surtout, on ne peut pas donner des instructions complexes (avec un haut niveau d'abstraction) comme "affiche une image" ou "calcule la moyenne d'un groupe de valeurs". Du coup, on utilise souvent des langages de programmation, qui eux ont des instructions plus sophistiquées, et qui simplifient le travail des programmeurs.
  
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).
+
L'implémentation physique d'un CPU est un sujet passionnant, mais qu'on réserve plutôt pour l'atelier "initiation à l'électronique numérique"...
  
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 !
+
==== Qu'est-ce que le binaire et le nombre de bits ? ====
 +
Les CPU ne savent manipuler que des 0 et des 1 : ce sont des circuits numériques (digital circuits, en anglais). Pour malgré tout représenter des nombres 'réels', il y a un moyen : utiliser la base 2, c'est à dire n'utiliser que 0 et 1 comme chiffres pour représenter des nombres quelconques : le nombre 6 que vous connaissez bien (formellement, 6*10^0), peut s'écrire 2+4, ou, en base 2: 1*2^2 + 1*2^1 + 0*2^0, ou encore 110 en base deux. Ces chiffres qui peuvent valoir 0 ou 1 sont appelés 'bits', ou chiffres binaires.
  
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...
+
Lors de la conception d'un CPU, on choisit la taille des nombres qu'il sait représenter, en choisissant le nombre de chiffres maximum qu'il sait manipuler d'un coup. Par exemple, le microcontroleur qu'on utilise dans une Arduino a un CPU 8 bits : il manipule des nombres à 8 chiffres binaires.
 +
En théorie, cela veut dire que le nombre le plus grand qu'on puisse représenter est 1*2^7 + 1*2^6 + 1*2^5 + 1*2^4 + 1*2^3 + 1*2^2 + 1*2^1 + 1*2^0 = 255. C'est pas énorme !
  
(TODO: picture PINOUT Arduino)
+
On peut se poser des questions aussi pour ce qui est des nombres négatifs, des nombres à virgule, etc... il y a bien sur des manières de faire, mais ce n'est pas évident pour un petit CPU comme celui de l'Arduino.
 +
 
 +
 
 +
Voir:
 +
* https://fr.wikiversity.org/wiki/Code_de_num%C3%A9ration/Introduction
 +
* https://fr.wikipedia.org/wiki/Virgule_fixe
 +
* https://fr.wikipedia.org/wiki/IEEE_754 (norme pour nombres à virgule: attention compliqué!)
 +
 
 +
==== A quoi ca sert/où 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...
  
 
=== L'univers 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!
+
Arduino a été pensé pour des étudiants designers, artistes... c'est à dire des non specialistes en électronique/programmation, pour qu'ils puissant bidouiller des trucs à base de microcontrôleurs. 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!
 +
 
 +
Projet à vocation pédagogique : rendre accessible aux néophytes des outils qui marchent/permettent de faire des choses. Wiring au moins autant que Arduino. Repose du du libre, donc est libre.
  
 +
==== C'est quoi Arduino ? ====
 
Par rapport à plein de cartes qui existaient auparavant, les gens d'Arduino ont fait plusieurs trucs géniaux:
 
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.
 
* 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 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.
+
* Pas un gadget ni un 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.
+
Tout cela a super bien fonctionné, et un nombre grandissant de gens se sont mis à s'en servir, à contribuer des améliorations, 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 ===
+
==== Anatomie d'une carte Arduino ====
'''Tour de presentation rapide du materiel dans le kit/la valise: carte + bread board, leds, capteurs, actionneurs.'''
+
présentation de la Nano: photo, feature sheet.
  
TODO: pictures de partout.
+
Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.
  
* Décrire comment marche une breadboard
+
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg image d'une Nano]
* Mises en garde/comment on fait un circuit
+
 
 +
 
 +
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png le pinout Arduino Nano]
 +
 
 +
==== Fonctionnalités de notre carte Arduino ====
 +
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 : on parle d'état haut et d'état bas, pour 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 (c'est à dire 0v ou 5v). Attention par contre à la limite de puissance! la puce ne sait pas fournir (ou absorber) 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 microcontrôleur 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...
 +
 
 +
Il contient en outre assez de mémoire vive (pour stocker nos variables) et de mémoire flash (pour stocker notre programme) pour la majeure partie des applications.
 +
 
 +
==== Utiliser l'outil logiciel ====
 +
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.
 +
* menus (choix de carte/port, exemples)
 +
* boutons upload & terminal
 +
* fenêtre d'édition du programme
 +
TODO: pictures de partout.
  
 +
==== Installation des logiciels ====
 
'''Installation/verification de l'IDE + du driver.'''
 
'''Installation/verification de l'IDE + du driver.'''
 +
Cette section devrait en réalité etre sur une page annexe qui explicite les étapes et est maintenue à jour en francais de manière indépendante.
  
 
TODO: pictures de partout.
 
TODO: pictures de partout.
Line 128: Line 201:
 
* Installation pas à pas du driver
 
* 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'''
+
=== Le matériel ===
* électricité, tension/courant
+
Nous allons découvrir chacun des éléments du kit de découverte Arduino.
* circuit électrique, schema/modélisation
+
  
'''Notions de programmation'''
+
TODO: pictures de partout ; est-ce qu'on renverrait pas vers des pages ailleurs qui contiennent ces infos?
* langage de programmation, compilation
+
* structure du programme (setup & loop)
+
* upload/execution
+
* Pour ce qui est du langage, voir la page https://www.arduino.cc/en/Reference/HomePage
+
  
'''Utiliser Arduino: l'IDE'''
+
*Breadboard
* menus (choix de carte/port, exemples)
+
** Décrire comment marche une breadboard
* boutons upload & terminal
+
** Mises en garde/comment on fait un circuit
* fenêtre d'édition du programme
+
* composant x:
 +
 
 +
== Piloter des 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.
 +
 
 +
=== Allumer et éteindre des LED ===
  
== Sorties ==
+
==== Exemple "blink" et fonctions de base ====
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.
+
Notre premier programme est s'appelle "Blink", il fait clignoter une LED. C'est un programme d'exemple fourni par Arduino. Le fichier du projet se trouve dans le menu Fichiers/Exemples/Basics.
  
=== Premier contact: l'exemple "Blink" ===
+
Une fois le fichier ouvert, cliquez sur le bouton "upload" pour compiler le programme, et le charger dans la mémoire du microcontrôleur. Résultat: la LED L, reliée à la pin D13, clignote.
==== 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!
+
  
 +
Cette manipulation simple représente le B.A.BA de l'utilisation de microcontrôleurs: bravo, vous venez de faire votre premier pas :)
  
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.
 
  
 +
'''Le montage:'''
 +
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 !
  
 
TODO: pictures.
 
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]
+
'''Comprendre le schéma:'''
 +
Le schéma utilisé est très simple: une led est reliée à la pin D13 de la carte ; une résistance est en série de celle-ci, pour limiter le courant à une valeur acceptable. L'orientation de la LED fait qu'il y a du courant qui la traverse lorsque la pin D13 est à l'état haut.
  
==== Analyse ====
+
On peut regarder [https://www.arduino.cc/en/uploads/Main/ArduinoNano30Schematic.pdf le schéma de la carte Nano] pour mieux comprendre, trouver les valeurs des composants, etc. Par exemple (et pour réviser les schémas électroniques) : la résistance vaut 330 ohm, et on peut imaginer que la led de couleur ambrée a une tension seuil de 2v. Lorsque la pin D13 est à l'état haut (5v dans le circuit, donc), il y a 3v aux bornes de la résistance de 330 ohm, soit un courant de 3/330, soit environ 10mA: c'est bon !
Essayons maintenant de comprendre ce qu'il se passe. Le schema utilisé est le suivant:
+
  
 
TODO: picture schematic sortie arduino resistance led.
 
TODO: picture schematic sortie arduino resistance led.
  
Regardons maintenant notre programme:
+
'''Le code source:'''Regardons maintenant le code source:
TODO: picture code Blink
+
* 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
  
TODO: analyse ligne à ligne de Blink: setup/loop, declaration variable 'led', etc etc.
+
TODO: pretty print source code blink
  
=== Défi 1: changer la vitesse de clignottement ===
+
==== Défi 1: changer la vitesse de clignottement ====
Question: Comment on fait pour changer la vitesse à laquelle ca clignote?
+
Question: Comment on fait pour changer la vitesse à laquelle clignote la led ?
  
Objectifs:
+
Ceci n'est pas une question théorique, mais pratique! Faites clignoter la led à une vitesse différente! Modifier le programmer, et testez en le chargeant sur la carte.
* 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é!}
 
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 ===
+
Résultat:
 +
* Compréhension d'un premier programme
 +
* Passage immédiat à l'action et interaction immédiate avec le sujet d'étude
 +
 
 +
==== 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.
 
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é.
+
Question pratique: faites donc un afficheur de SOS en morse sur la led L !
 
+
  
 
Réponses:  
 
Réponses:  
* diversité d'approches/de strategies: utiliser des fonctions... voire faire de simples copier/coller.
+
* diversité d'approches, de stratégies:
* paramétrisation: le temps d'allumage peut être écrit "en dur" ou bien une variable, dont la valeur est facile à modifier à un seul endroit.
+
** 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;
 +
 
 +
Résultat:
 +
* on a désormais un programme un peu plus sophistiqué que le simple clignotement
  
Versions de code:
 
* Copier coller versus fonctions
 
* valeurs "en dur" versus valeurs paramétrables
 
  
 
Questions subsidiaires:
 
Questions subsidiaires:
* comment faire varier la vitesse du morse?
+
* 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?
+
* 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).
Réponse:
+
* bien structurer son programme, et anticiper ce à quoi il va pouvoir servir est important.
+
  
  
=== Défi 3: ultra rapide ===
+
TODO: pretty print source code de ces questions subsidiaires
 +
 
 +
En conclusion: même sur un exemple simple, bien structurer son programme et anticiper ce à quoi il va pouvoir servir est important.
 +
 
 +
=== Allumer des LED avec intensité variable ===
 +
 
 +
==== Défi 3: ultra rapide ====
 
Question: Il se passe quoi si on fait clignoter suuuper vite?
 
Question: Il se passe quoi si on fait clignoter suuuper vite?
  
Objectif: découvrir la notion de PWM (Pulse Width Modulation).
+
Là encore: faites le test! Mettez ''delay(100)'', puis ''delay(10)'' et ''delay(1)''.
  
Réponses:
+
Réponse: du fait de la persistance 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. Notamment: avec 100 et 100, il y a 5 flash par seconde. avec 10 et 10: 50 par seconde. Avec 1 et 1, 500 par seconde.
* persistence rétinienne: on ne voit plus les flashs indépendants, mais une intensité lumineuse "moyenne".
+
  
Questions subsidiaires:
+
Question: ajuster la vitesse de clignotement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.
* 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.
+
Réponse: dès 10 et 10, soit environ 50Hz (50 clignotements par seconde), il devient difficile de distinguer les flashs individuels. On arriver en tout cas plus à les compter !
 +
 
 +
Question: ca veut dire quoi, super vite, pour le microcontrôleur?
 +
 
 +
Réponse: l'horloge de référence du processeur central (un peu comme un métronome) est à la fréquence de 16MHz, donc, grosso modo, celui-ci 16 millions de choses par seconde! En gros: 16000000 alors que dès 50 on arrive plus à distinguer...  
 +
 
 +
==== Défi 4 : jouer avec les délais ====
 +
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?
 +
 
 +
Allez-y, tentez par exemple ''delay(200)'' et ''delay(800)'', et inversement ''delay(800)'' et ''delay(200)''. Dit autrement: allumé 200ms puis éteint 800ms, et inversement, éteint 200ms puis allumé 800ms. Testez d'autres valeurs, par exemple: 1/9, 3/7, 5/5, 7/3, 9/1...
 +
 
 +
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’œil. Même si le microcontrôleur n'a pas de moyen direct de générer une valeur analogique (c'est à dire, pas seulement "marche" ou "arrêt", mais aussi des valeurs intermédiaires), avec l'astuce de la PWM, on peut obtenir un résultat équivalent.
 +
 
 +
==== Notion de PWM et sortie analogique ====
 +
Ce que l'on vient de découvrir s'appelle PWM, pour Pulse Width Modulation, ou MLI en français, pour Modulation de Largeur d'Impulsion.
 +
 
 +
C'est une technique qui permet simuler une sortie analogique (c'est à dire valeur quelconque entre 0v ou 5v, au lieu d'exclusivement 0v ou 5v pour une valeur digitale) à partir de quelque chose en tout ou rien. On parle aussi de hachage, ou découpage. C'est une technique très, très fréquente en électronique, parce qu'il est plus facile (voir uniquement possible) de faire du tout ou rien, alors que souvent on veut des variations continues.
  
 
TODO: pictures pour l'explication PWM/rapport cyclique, etc
 
TODO: pictures pour l'explication PWM/rapport cyclique, etc
  
=== PWM et sortie analogique ===
+
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.
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.
+
Note : il existe d'autres techniques pour avoir des valeurs variables à partir de tout ou rien, mais la PWM est souvent la plus pratique et simple. Pour les curieux, autres techniques: réseau R-2R, transistor en régime linéaire, DAC intégrés (différentes technos), ... TODO: liens wikipedia voire montages & composants pertinents...
  
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!
+
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====
 +
C'est tellement pratique de pouvoir générer une tension arbitraire entre 0v et 5v, qu'on aurait bien envie d'avoir une fonction toute fait qui le gère. Ca tombe bien, Arduino a une fonction toute prête pour cela: analogWrite (voir [https://www.arduino.cc/en/Reference/AnalogWrite la page de référence]).
  
=== 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...
+
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.
 +
On va créer une fonction my_analogWrite(int pin, int value):
 +
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).
 +
* value étant une valeur entre 0 et 255, donnant l'intensité
 +
Solution primitive: on pourrait utiliser quelque chose du genre de:
 +
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);
  
== Entrées ==
+
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?
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 ===
+
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:
 +
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));
  
Remarque préliminaire: quel exemple utiliser? en créer un avec internal pullup?
+
TODO: Code en pretty print
*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?).
+
Note: on peut aussi aller regarder le code source de la librairie analogWrite elle-meme. On le trouve dans les fichiers des dossiers ou l'IDE est installé, et [https://github.com/arduino/Arduino/search?p=2&q=analogWrite il est sur github :] le fichier source [https://github.com/arduino/Arduino/blob/8385aedc642d6cd76b50ac5167307121007e5045/hardware/arduino/avr/cores/arduino/wiring_analog.c est ici].
* analyse code (reference sur le site Arduino)
+
  
Version alternative: utiliser une internal pullup, et donc une logique inversee.
+
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:
 +
* il est générique, et marche sur plusieurs types de cartes Arduino (il
 +
* il utilise des fonctionnalités qu'on ne connait pas encore: en matériel, le microcontrôleur sait générer des PWM "tout seul" grâce à un bout de matériel spécialement prévu pour. Pour les curieux, tout cela est expliqué dans la doc technique du composant, [http://www.atmel.com/images/atmel-8271-8-bit-avr-microcontroller-atmega48a-48pa-88a-88pa-168a-168pa-328-328p_datasheet_complete.pdf à la page 111/660] dans le chapitre sur le périphérique 'timer' : c'est un peu obscur... mais ca se décrypte, avec (beaucoup de) motivation. Une fois configuré, le CPU n'a pas à intervenir pour que la PWM soit générée. Ultra pratique pour pouvoir faire autre chose en parallèle...
  
=== défi 1: changer le fonctionnement ===
+
==== Exemple Fade et fonction analogWrite ====
 +
Le code se trouve dans le menu Exemple/Basics/Fade.
 +
 
 +
'''Le schéma:''' est très similaire à celui de Blink... mais il faut relier la LED à une pin marquée ~ pour pouvoir utiliser la fonction analogWrite, dépendante de fonctionnalité spéciales du matériel. On va utiliser la pin 9, par exemple. Attention à ne pas oublier de mettre une résistance en série pour limiter le courant !
 +
 
 +
TODO: pretty print schéma/montage breadboard & pic
 +
 
 +
'''Le code source:'''Regardons maintenant le code source:
 +
* 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 9 est une sortie
 +
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:
 +
** application de la valeur actuelle de luminosité (brightness) sur la led
 +
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)
 +
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.
 +
** un petit délai pour voir les variations
 +
 
 +
 
 +
TODO: pretty print source code Fade
 +
 
 +
==== Défi 6 : fade & RGB ====
 +
Faisons des modifications à fade: utiliser une led RGB, c'est à dire gérer plusieurs sorties à la fois! On peut ensuite générer des séquences aussi variées qu'on veut !
 +
 
 +
=== Micro projet: feu tricolore ===
 +
Avec tout ce qu'on vient de voir, on est en mesure de concevoir et réaliser un feu tricolore. On va utiliser trois leds et les résistances associées: une verte, une jaune (ou orange) et une rouge. Les résistances seront choisies à une valeur appropriée pour limiter le courant.
 +
 
 +
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.
 +
 
 +
Pour commencer, on peut faire un feu simple: au vert pendant 3 secondes, orange pendant 1 seconde, et rouge pendant 3 secondes, puis on recommence.
 +
 
 +
TODO: feu trivial: pic montage
 +
 
 +
TODO: feu trivial: code source "solution"
 +
 
 +
On peut ensuite imaginer plusieurs évolutions/améliorations: ajout d'un témoin vert/rouge de passage piéton, gestion d'une intersection (c'est à dire, deux jeux voire plus de trois leds)... et assez rapidement, on va avoir envie de faire d'autres choses, comme par exemple avoir un bouton de demande passage au vert pour les piétons, voire un capteur de présence de véhicule... on peut le faire, mais il nous faut apprendre comment ca marche d'avoir des entrées sur le microcôntroleur !
 +
 
 +
== Lire l'état d'entrées ==
 +
Pour réellement faire plein de choses intéressantes avec un microcontrôleur, on a besoin de savoir mesurer des trucs dans le monde réel, pour fournir des informations à notre application. Dans toute cette section, nous allons utiliser le joystick contenu dans le kit de découverte Arduino.
 +
 
 +
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===
 +
Commençons par la plus simple des entrées: un interrupteur basique. Il y en a un par exemple dans le Joystick du kit: lorsqu'on appuie dessus, on entend distinctement un "clic".
 +
 
 +
 
 +
==== Exemple "Button" ====
 +
Le code se trouve dans le menu Fichier/Examples/Digital.
 +
 
 +
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.
 +
 
 +
TODO picture: fritzing schéma
 +
 
 +
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.
 +
 
 +
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé
 +
 
 +
'''Le code:'''
 +
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis: on indique que la pin 13 est une sortie (pour piloter la led) et que la pin 2 est une entrée.
 +
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.
 +
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:
 +
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]
 +
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.
 +
 
 +
==== 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) ?
 
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:
+
TODO: détailler l'énoncé du défi.
 +
 
 +
Réponse: structure du code
 
* Lire l'entrée
 
* Lire l'entrée
 
* prendre des décisions
 
* prendre des décisions
 
* appliquer les sorties.
 
* appliquer les sorties.
  
Exemple (désolé pour la mise en page) :
+
Désolé pour la mise en page (en attente de pretty print wiki) :
  
 
<code>
 
<code>
Line 290: Line 443:
 
   }
 
   }
  
   delay(100); // permet de faire un debounce
+
   delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.
 
}
 
}
 
</code>
 
</code>
  
=== défi 2: menu ===
+
==== Défi 2: menu simple par durée d'appui ====
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.
+
Comment on peut faire "sentir" à la carte un peu plus que juste "marche/arret" ? Par exemple, en différenciant les appuis longs et appuis courts.
  
Exemple d'interface "avancée":
+
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.
* défi 2a: compter le nombre d'appuis successifs
+
* défi 2b: différencier les appuis longs ou courts
+
  
En fonction de cela:
+
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)
* 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.
+
  
 +
 +
==== Défi 3 : menu simple par comptage d'impulsions ====
 +
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/détecter le doubleclic.
 +
 +
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.
 +
 +
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?
 +
 +
==== Notion de rebond ====
 +
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!
 +
 +
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?
 +
 +
Note: en utilisant INPUT_PULLUP dans pinMode, on peut se passer de la résistance. En effet, le microcontroleur contient des résistances de pull-up, qu'on peut activer en logiciel. Voir par exemple l'exemple [https://www.arduino.cc/en/Tutorial/InputPullupSerial InputPullupSerial].
 +
 +
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ...
  
 
Attention, piège du bounce (ou rebond, en francais).
 
Attention, piège du bounce (ou rebond, en francais).
Line 327: Line 492:
 
* Sortie: allumer ou éteindre une LED
 
* Sortie: allumer ou éteindre une LED
  
Voyons maintenant des entrées/sorties encore plus cool !
+
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.
  
=== Potentiomètre et Analog in ===
+
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===
Exemple de code potard vers fade.
+
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.
* on fait le montage
+
* upload code
+
* demo/test.
+
  
*"analyse" schematic (eg entrée arduino analog potard).
+
==== Exemple "AnalogInput" ====
*analyse code
+
Nous allons utiliser le programme d'exemple qui s'appelle "AnalogInput", il fait clignoter une LED avec une vitesse réglable par potentiomètre. Le fichier du projet se trouve dans le menu Fichiers/Exemples/Analog.
=> OK! On peut mesurer des trucs mieux que juste marche/arret.
+
  
 +
'''Le montage:''' TODO frizting.
  
Pratiquement l'exemple https://www.arduino.cc/en/Tutorial/AnalogInput sauf que nous on connait déjà les PWM.
+
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!
  
=== Bonus ===
+
'''Le code source:'''
*défi: reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).
+
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:
*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...).
+
** la pin 13 (ledPin) est une sortie.
*défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)
+
** on ne déclare pas d'entrée Analog!
 +
* on se fait des variables: sensorValue.
 +
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:
 +
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref
 +
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink
 +
 
 +
TODO: pretty print source code AnalogInput
 +
 
 +
==== Défi : potard vers fade ====
 +
TODO: texte.
  
 
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".
 
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".
  
== Communication ==
+
Ici, relier à Fade.
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.
+
* Relation linéaire
 +
 
 +
Réponse: bla bla code.
 +
 
 +
==== Défi : potard roulette russe ====
 +
TODO: texte.
 +
 
 +
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".
 +
 
 +
* Relation seuil... et notion d'hysteresis.
 +
 
 +
Réponse: bla bla code.
 +
 
 +
=== Microprojets: retour aux vieux codes, coffre fort ===
 +
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!
 +
 
 +
Revisitons nos anciens codes:
 +
* 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)
 +
* menu avec bouton, joystick... à préciser :P
 +
 
 +
TODO: détailler les énoncés, donner les réponses code et montage
 +
 
 +
== Communication avec le PC ==
 +
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 périphérique UART, et la librairie "Serial". Voyons comment tout cela fonctionne...
  
 
=== Communication Arduino -> PC ===
 
=== Communication Arduino -> PC ===
*On reprend notre montage avec le potard, et on charge un autre exemple de code:analogin serial out
+
Permet de remonter des informations, des mesures...
*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!
+
==== Exemple "AnalogInOutSerial" ====
*analyse du code: utiliser le module HW de communication série, qui permet de parler au PC, et envoyer des infos.
+
Nous allons utiliser le programme d'exemple qui s'appelle "AnalogInOutSerial", il fait XXXX et YYYY. Le fichier du projet se trouve dans le menu Fichiers/Exemples/Analog.
  
=== défi 1 : afficher autre chose que la valeur brute! ===
+
'''Le montage:''' TODO frizting.
*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.
+
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?
 +
 
 +
'''Le code source:'''
 +
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:
 +
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.
 +
** on ne déclare pas d'entrée Analog!
 +
** D13 est une sortie.
 +
* on se fait des variables: sensorValue et outputValue
 +
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:
 +
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref
 +
** map: pour changer la dynamique. Indispensable ici!
 +
** Serial.print de chaine fixe.
 +
** Serial.print de  variable.
 +
 
 +
 
 +
TODO: pretty print source code AnalogInSerialOut
 +
 
 +
==== Défi  : afficher autre chose que la valeur brute? ====
 +
*Par exemple, un coffre fort? Eg si potards à la bonne valeur (voire, une suite de positions), afficher un mot de passe sur port série. Ou roulette russe avec des hints
 +
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.
 +
 
 +
==== Défi : serial et debug ====
 
*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...
 
*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 ===
 
=== Communication PC -> Arduino ===
exemple a creer:pilotage kbd vers allume/eteindre led.
+
Envoyer des commandes et des infos à l'Arduino depuis le PC!
* 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.
+
==== Exemple "SerialInAction" ====
 +
Nous allons utiliser le programme d'exemple fait sur mesure SerialInAction (TODO: nommer mieux), il fait XXXX et YYYY. Le fichier du projet se trouve XXX
 +
 
 +
'''Le montage:''' TODO frizting.
 +
 
 +
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13
 +
 
 +
'''Le code source:'''
 +
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:
 +
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.
 +
** D13 est une sortie.
 +
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:
 +
** vérification si données dispo avec fonction TODO ref
 +
** switch TODO ref pour choisir l'action selon le caractere recu.
  
*Analyse du code, pour comprendre ce qui s'est passé
 
  
 +
TODO: pretty print source code custom exemple:
  
 +
TODO: header comment
 
byte inByte;
 
byte inByte;
  
Line 393: Line 623:
 
}
 
}
  
=== défi 2 : ajouter des fonctions ===
+
==== Défi : piloter plusieurs leds ====
 +
TODO texte et redécoupage.
 
*exemple: pilotage RGB
 
*exemple: pilotage RGB
 +
 +
==== Défi : piloter Fade ====
 +
TODO texte et redécoupage.
 
*exemple: valeurs/paramètres de fade
 
*exemple: valeurs/paramètres de fade
*exemple: clignottements différents
+
*exemple: clignotements différents, eg trig de séquences
 +
 
 +
==== Défi : set de valeurs..? ====
 
*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...)
 
*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...)
 +
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!
  
=== bonus ===
+
=== Microprojets: XXX ===
*exemple: Terminal morse (avec potard pour vitesse)
+
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?
 +
 
 +
backdoor paramétrage central intersection
  
 
== Pour aller plus loin ==
 
== Pour aller plus loin ==
 +
TODO texte...
 
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.
 
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!
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!
+
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)
  
==== output buzzer ====
+
=== Capteurs de température et de lumière ===
*schema
+
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.
*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 ====
+
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!
*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).
 
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).
Line 430: Line 660:
 
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.
 
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.
 
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.
 +
 +
 +
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.
  
 
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.
 
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.
Line 437: Line 670:
 
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
 
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 ====
+
==== Exemple : capteur de lumiere ====
*schema: pont diviseur de tension. Expérimentation pour trouver la valeur optimale de résistance
+
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...
*code example: on peut reprendre tous ceux où on avait un potentiometer avant...
+
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.
*defis/applis marrantes
+
 
 +
==== Exemple : capteur de température ====
 +
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...
 +
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.
 +
 
 +
 
 +
=== Buzzer et sons ===
 +
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.
 +
 
 +
==== Exemple : cri de la victoire ====
 +
Code exemple de tone
 +
 
 +
==== Défi : morse en audio ====
 +
On pourrait avoir le terminal Morse en audio plutot que sur la led.
 +
 
 +
==== Défi : theremine ====
 +
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.
 +
 
 +
=== Microservomoteur et mouvement ===
 +
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.
 +
 
 +
 
 +
==== Exemple: swipe ====
 +
analyse, comme d'hab.
 +
 
 +
==== Exemple: knob ====
 +
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.
 +
 
 +
==== Défi : trappe aération serre ====
 +
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.
 +
 
 +
=== Microprojet: poubelle intelligente ===
 +
capteur de lumière/capteur de proximité => poulie, servomoteur
  
==== capteur température ====
+
=== Microprojet: bras robot ===
*schema: pont diviseur de tension. Expérimentation pour trouver la valeur optimale de résistance
+
pilotage par potards et par serial port du kit bras robot 4 axes.
*code example: on peut reprendre tous ceux où on avait un potentiometer avant...
+
*defis/applis marrantes
+
  
 
= Conclusion =
 
= Conclusion =
Cette formation a permis de faire nos premiers pas avec un microcontroleur, en utilisant Arduino:
+
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:
* sorties (digitales et analogiques),
+
* piloter des sorties (digitales et analogiques),
* entrées
+
* lire l'état d'entrées (digitales et analogiques),
* communications avec le PC
+
* communications avec le PC (dans les deux sens)
* capteurs et actionneurs sympa!
+
* 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 réalisé plusieurs défis et micro-projets. Quand on veut faire un projet quelconque de plus grande envergure, on fait comme cela aussi: on commence par examiner chacun des petits bouts, avant d'assembler les pièces du puzzle.
  
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.
+
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.
  
 
== la suite ==
 
== 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?)
+
* Assister à la formation "mon premier petit projet Arduino". L'idée est justement d'utiliser d'autres modules capteurs/actionneurs pour réaliser 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?
 
=> 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, ...
+
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...
 
=> Qu'est ce que vous voulez apprendre de plus/approfondir?
 
=> Qu'est ce que vous voulez apprendre de plus/approfondir?
  

Latest revision as of 17:58, 15 March 2017


Contents

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.

Cette page, un peu dense O:-) rassemble plein d'infos et de pistes pour suivre cette formation. Un peu de patience, un jour tout sera proprement remis en forme et digeste... n'hésitez pas à apporter des corrections et modifications!

TODO/meta

  • séparer/intégrer/linker les pages "autres" directement connexes: install IDE, contenu du kit découverte, item du distributeur, formations préliminaires (eg électronique & programmation), et peut être micro/miniprojets?
  • ajouter shitloads of pictures
  • ajouter le module spoileralert pour masquer les réponses...
  • schéma frizting
  • prettyprint sourcecode...
  • couper en n pages (pour les 3 troncs de contenu, les annexes?), voire préparer pour migration vers learn.electrolab.fr

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 https://www.arduino.cc/en/Main/Software


Les exemples et exercices de cette page exploitent le contenu du kit de démarrage Arduino sauce Electrolab. Il est en vente au lab pour 30€, et plusieurs exemplaires sont disponibles en prêt pour suivre cette formation.

Contenu :

  • Arduino Nano + cable USB
  • breadboard pour prototypage et cables male/male et femelle/femelle
  • potentiomètre et 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

Attention, les cartes que nous employons nécessitent un pilote de périphérique spécifique ! Ce sont des clones made in China à vil prix.

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.

Dans le cadre de cette formation, on va s'intéresser aux fonctionnalités de base des microcontrôleurs, et à la manière de concevoir un projet utilisant un microcontrôleur. C'est un premier pas vers une grande diversité de projets !

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.


Microcontrôleurs

Pour en savoir plus, voici la page du fabricant de la puce au coeur de la carte qu'on va utiliser: http://www.atmel.com/devices/atmega328p.aspx

Par ailleurs, le document technique de référence (datasheet) de ce composant est intéressant à lire ou survoler: http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf

https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR


Qu'est-ce qu'un microcontrôleur?

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.

Qu'est-ce qu'un microprocesseur ?

En anglais: CPU, central processing unit: unité centrale de calcul. C'est le bidule au coeur d'un ordinateur, qui exécute des instructions correspondant à un programme. Ces instructions sont très simples. Par exemple :

  • ajouter la valeur 42 à la case mémoire #3
  • si la case mémoire #3 est nulle, aller exécuter l'instruction 2 cases plus bas dans la mémoire programme
  • sinon, exécuter celle 1 case plus bas dans la mémoire programme

Pas facile de donner directement des ordres dans ce langage (l'assembleur), car il faut connaitre exactement ce que sait faire tel ou tel CPU, et surtout, on ne peut pas donner des instructions complexes (avec un haut niveau d'abstraction) comme "affiche une image" ou "calcule la moyenne d'un groupe de valeurs". Du coup, on utilise souvent des langages de programmation, qui eux ont des instructions plus sophistiquées, et qui simplifient le travail des programmeurs.

L'implémentation physique d'un CPU est un sujet passionnant, mais qu'on réserve plutôt pour l'atelier "initiation à l'électronique numérique"...

Qu'est-ce que le binaire et le nombre de bits ?

Les CPU ne savent manipuler que des 0 et des 1 : ce sont des circuits numériques (digital circuits, en anglais). Pour malgré tout représenter des nombres 'réels', il y a un moyen : utiliser la base 2, c'est à dire n'utiliser que 0 et 1 comme chiffres pour représenter des nombres quelconques : le nombre 6 que vous connaissez bien (formellement, 6*10^0), peut s'écrire 2+4, ou, en base 2: 1*2^2 + 1*2^1 + 0*2^0, ou encore 110 en base deux. Ces chiffres qui peuvent valoir 0 ou 1 sont appelés 'bits', ou chiffres binaires.

Lors de la conception d'un CPU, on choisit la taille des nombres qu'il sait représenter, en choisissant le nombre de chiffres maximum qu'il sait manipuler d'un coup. Par exemple, le microcontroleur qu'on utilise dans une Arduino a un CPU 8 bits : il manipule des nombres à 8 chiffres binaires. En théorie, cela veut dire que le nombre le plus grand qu'on puisse représenter est 1*2^7 + 1*2^6 + 1*2^5 + 1*2^4 + 1*2^3 + 1*2^2 + 1*2^1 + 1*2^0 = 255. C'est pas énorme !

On peut se poser des questions aussi pour ce qui est des nombres négatifs, des nombres à virgule, etc... il y a bien sur des manières de faire, mais ce n'est pas évident pour un petit CPU comme celui de l'Arduino.


Voir:

A quoi ca sert/où 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...

L'univers Arduino

Arduino a été pensé pour des étudiants designers, artistes... c'est à dire des non specialistes en électronique/programmation, pour qu'ils puissant bidouiller des trucs à base de microcontrôleurs. 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!

Projet à vocation pédagogique : rendre accessible aux néophytes des outils qui marchent/permettent de faire des choses. Wiring au moins autant que Arduino. Repose du du libre, donc est libre.

C'est quoi Arduino ?

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 ni un 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 améliorations, 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.

Anatomie d'une carte Arduino

présentation de la Nano: photo, feature sheet.

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

Fonctionnalités de notre carte Arduino

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 : on parle d'état haut et d'état bas, pour 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 (c'est à dire 0v ou 5v). Attention par contre à la limite de puissance! la puce ne sait pas fournir (ou absorber) 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 microcontrôleur 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...

Il contient en outre assez de mémoire vive (pour stocker nos variables) et de mémoire flash (pour stocker notre programme) pour la majeure partie des applications.

Utiliser l'outil logiciel

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.

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

TODO: pictures de partout.

Installation des logiciels

Installation/verification de l'IDE + du driver. Cette section devrait en réalité etre sur une page annexe qui explicite les étapes et est maintenue à jour en francais de manière indépendante.

TODO: pictures de partout.

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



Le matériel

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

TODO: pictures de partout ; est-ce qu'on renverrait pas vers des pages ailleurs qui contiennent ces infos?

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

Piloter des 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.

Allumer et éteindre des LED

Exemple "blink" et fonctions de base

Notre premier programme est s'appelle "Blink", il fait clignoter une LED. C'est un programme d'exemple fourni par Arduino. Le fichier du projet se trouve dans le menu Fichiers/Exemples/Basics.

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

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


Le montage: 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 !

TODO: pictures.

Comprendre le schéma: Le schéma utilisé est très simple: une led est reliée à la pin D13 de la carte ; une résistance est en série de celle-ci, pour limiter le courant à une valeur acceptable. L'orientation de la LED fait qu'il y a du courant qui la traverse lorsque la pin D13 est à l'état haut.

On peut regarder le schéma de la carte Nano pour mieux comprendre, trouver les valeurs des composants, etc. Par exemple (et pour réviser les schémas électroniques) : la résistance vaut 330 ohm, et on peut imaginer que la led de couleur ambrée a une tension seuil de 2v. Lorsque la pin D13 est à l'état haut (5v dans le circuit, donc), il y a 3v aux bornes de la résistance de 330 ohm, soit un courant de 3/330, soit environ 10mA: c'est bon !

TODO: picture schematic sortie arduino resistance led.

Le code source:Regardons maintenant le code source:

  • 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

TODO: pretty print source code blink

Défi 1: changer la vitesse de clignottement

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

Ceci n'est pas une question théorique, mais pratique! Faites clignoter la led à une vitesse différente! Modifier le programmer, et testez en le chargeant sur la carte.

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

Résultat:

  • Compréhension d'un premier programme
  • Passage immédiat à l'action et interaction immédiate avec le sujet d'étude

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.

Question pratique: faites donc un afficheur de SOS en morse sur la led L !

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;

Résultat:

  • on a désormais un programme un peu plus sophistiqué que le simple clignotement


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).


TODO: pretty print source code de ces questions subsidiaires

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

Allumer des LED avec intensité variable

Défi 3: ultra rapide

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

Là encore: faites le test! Mettez delay(100), puis delay(10) et delay(1).

Réponse: du fait de la persistance 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. Notamment: avec 100 et 100, il y a 5 flash par seconde. avec 10 et 10: 50 par seconde. Avec 1 et 1, 500 par seconde.

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

Réponse: dès 10 et 10, soit environ 50Hz (50 clignotements par seconde), il devient difficile de distinguer les flashs individuels. On arriver en tout cas plus à les compter !

Question: ca veut dire quoi, super vite, pour le microcontrôleur?

Réponse: l'horloge de référence du processeur central (un peu comme un métronome) est à la fréquence de 16MHz, donc, grosso modo, celui-ci 16 millions de choses par seconde! En gros: 16000000 alors que dès 50 on arrive plus à distinguer...

Défi 4 : jouer avec les délais

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

Allez-y, tentez par exemple delay(200) et delay(800), et inversement delay(800) et delay(200). Dit autrement: allumé 200ms puis éteint 800ms, et inversement, éteint 200ms puis allumé 800ms. Testez d'autres valeurs, par exemple: 1/9, 3/7, 5/5, 7/3, 9/1...

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’œil. Même si le microcontrôleur n'a pas de moyen direct de générer une valeur analogique (c'est à dire, pas seulement "marche" ou "arrêt", mais aussi des valeurs intermédiaires), avec l'astuce de la PWM, on peut obtenir un résultat équivalent.

Notion de PWM et sortie analogique

Ce que l'on vient de découvrir s'appelle PWM, pour Pulse Width Modulation, ou MLI en français, pour Modulation de Largeur d'Impulsion.

C'est une technique qui permet simuler une sortie analogique (c'est à dire valeur quelconque entre 0v ou 5v, au lieu d'exclusivement 0v ou 5v pour une valeur digitale) à partir de quelque chose en tout ou rien. On parle aussi de hachage, ou découpage. C'est une technique très, très fréquente en électronique, parce qu'il est plus facile (voir uniquement possible) de faire du tout ou rien, alors que souvent on veut des variations continues.

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

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

Note : il existe d'autres techniques pour avoir des valeurs variables à partir de tout ou rien, mais la PWM est souvent la plus pratique et simple. Pour les curieux, autres techniques: réseau R-2R, transistor en régime linéaire, DAC intégrés (différentes technos), ... TODO: liens wikipedia voire montages & composants pertinents...

Défi 5 : générer une sortie analogique à partir de 0v et 5v

C'est tellement pratique de pouvoir générer une tension arbitraire entre 0v et 5v, qu'on aurait bien envie d'avoir une fonction toute fait qui le gère. Ca tombe bien, Arduino a une fonction toute prête pour cela: analogWrite (voir la page de référence).


Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version. On va créer une fonction my_analogWrite(int pin, int value):

  • pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).
  • value étant une valeur entre 0 et 255, donnant l'intensité

Solution primitive: on pourrait utiliser quelque chose du genre de:

  • digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);

Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?

Réponse: on peut utiliser la fonction DelayMicroseconds au lieu de delay tout court:

  • digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));

TODO: Code en pretty print


Note: on peut aussi aller regarder le code source de la librairie analogWrite elle-meme. On le trouve dans les fichiers des dossiers ou l'IDE est installé, et il est sur github : le fichier source est ici.

Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:

  • il est générique, et marche sur plusieurs types de cartes Arduino (il
  • il utilise des fonctionnalités qu'on ne connait pas encore: en matériel, le microcontrôleur sait générer des PWM "tout seul" grâce à un bout de matériel spécialement prévu pour. Pour les curieux, tout cela est expliqué dans la doc technique du composant, à la page 111/660 dans le chapitre sur le périphérique 'timer' : c'est un peu obscur... mais ca se décrypte, avec (beaucoup de) motivation. Une fois configuré, le CPU n'a pas à intervenir pour que la PWM soit générée. Ultra pratique pour pouvoir faire autre chose en parallèle...

Exemple Fade et fonction analogWrite

Le code se trouve dans le menu Exemple/Basics/Fade.

Le schéma: est très similaire à celui de Blink... mais il faut relier la LED à une pin marquée ~ pour pouvoir utiliser la fonction analogWrite, dépendante de fonctionnalité spéciales du matériel. On va utiliser la pin 9, par exemple. Attention à ne pas oublier de mettre une résistance en série pour limiter le courant !

TODO: pretty print schéma/montage breadboard & pic

Le code source:Regardons maintenant le code source:

  • 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 9 est une sortie
  • la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:
    • application de la valeur actuelle de luminosité (brightness) sur la led
    • mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)
    • mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.
    • un petit délai pour voir les variations


TODO: pretty print source code Fade

Défi 6 : fade & RGB

Faisons des modifications à fade: utiliser une led RGB, c'est à dire gérer plusieurs sorties à la fois! On peut ensuite générer des séquences aussi variées qu'on veut !

Micro projet: feu tricolore

Avec tout ce qu'on vient de voir, on est en mesure de concevoir et réaliser un feu tricolore. On va utiliser trois leds et les résistances associées: une verte, une jaune (ou orange) et une rouge. Les résistances seront choisies à une valeur appropriée pour limiter le courant.

Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.

Pour commencer, on peut faire un feu simple: au vert pendant 3 secondes, orange pendant 1 seconde, et rouge pendant 3 secondes, puis on recommence.

TODO: feu trivial: pic montage

TODO: feu trivial: code source "solution"

On peut ensuite imaginer plusieurs évolutions/améliorations: ajout d'un témoin vert/rouge de passage piéton, gestion d'une intersection (c'est à dire, deux jeux voire plus de trois leds)... et assez rapidement, on va avoir envie de faire d'autres choses, comme par exemple avoir un bouton de demande passage au vert pour les piétons, voire un capteur de présence de véhicule... on peut le faire, mais il nous faut apprendre comment ca marche d'avoir des entrées sur le microcôntroleur !

Lire l'état d'entrées

Pour réellement faire plein de choses intéressantes avec un microcontrôleur, on a besoin de savoir mesurer des trucs dans le monde réel, pour fournir des informations à notre application. Dans toute cette section, nous allons utiliser le joystick contenu dans le kit de découverte Arduino.

Bouton et entrée digitale (au choix, 0v ou 5v)

Commençons par la plus simple des entrées: un interrupteur basique. Il y en a un par exemple dans le Joystick du kit: lorsqu'on appuie dessus, on entend distinctement un "clic".


Exemple "Button"

Le code se trouve dans le menu Fichier/Examples/Digital.

Le montage: TODO description du montage: gnd, SW, résistance pulldown.

TODO picture: fritzing schéma

Comprendre le schéma: rôle de la pulldown... et pullup.

TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé

Le code:

  • la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis: on indique que la pin 13 est une sortie (pour piloter la led) et que la pin 2 est une entrée.
  • on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.
  • la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:
    • lecture de l'état de la pin 2 grâce à la fonction digitalRead
    • en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.

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) ?

TODO: détailler l'énoncé du défi.

Réponse: structure du code

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

Désolé pour la mise en page (en attente de pretty print wiki) :

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: on verra plus tard ce que ca veut dire.

}

Défi 2: menu simple par durée d'appui

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

Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.

En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)


Défi 3 : menu simple par comptage d'impulsions

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/détecter le doubleclic.

Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.

  • toggle avec deux leds? +/- vitesse? analogWrite/Fade?

Notion de rebond

Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!

Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?

Note: en utilisant INPUT_PULLUP dans pinMode, on peut se passer de la résistance. En effet, le microcontroleur contient des résistances de pull-up, qu'on peut activer en logiciel. Voir par exemple l'exemple InputPullupSerial.

Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ...

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 ! => OK! On peut mesurer des trucs mieux que juste marche/arret.

Potentiomètre et entrée analogique (mesure entre 0v et 5v)

C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.

Exemple "AnalogInput"

Nous allons utiliser le programme d'exemple qui s'appelle "AnalogInput", il fait clignoter une LED avec une vitesse réglable par potentiomètre. Le fichier du projet se trouve dans le menu Fichiers/Exemples/Analog.

Le montage: TODO frizting.

Comprendre le schéma: pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!

Le code source:

  • la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:
    • la pin 13 (ledPin) est une sortie.
    • on ne déclare pas d'entrée Analog!
  • on se fait des variables: sensorValue.
  • la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:
    • mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref
    • utiliser la valeur lue comme paramètre de la fonction delay dans l'exemple Blink

TODO: pretty print source code AnalogInput

Défi : potard vers fade

TODO: texte.

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

Ici, relier à Fade.

  • Relation linéaire

Réponse: bla bla code.

Défi : potard roulette russe

TODO: texte.

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

  • Relation seuil... et notion d'hysteresis.

Réponse: bla bla code.

Microprojets: retour aux vieux codes, coffre fort

Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!

Revisitons nos anciens codes:

  • 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)
  • menu avec bouton, joystick... à préciser :P

TODO: détailler les énoncés, donner les réponses code et montage

Communication avec le PC

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 périphérique UART, et la librairie "Serial". Voyons comment tout cela fonctionne...

Communication Arduino -> PC

Permet de remonter des informations, des mesures...

Exemple "AnalogInOutSerial"

Nous allons utiliser le programme d'exemple qui s'appelle "AnalogInOutSerial", il fait XXXX et YYYY. Le fichier du projet se trouve dans le menu Fichiers/Exemples/Analog.

Le montage: TODO frizting.

Comprendre le schéma/installation: TODO rien de spécial..? notions (baudrate, moniteur série) à la place?

Le code source:

  • la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:
    • on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.
    • on ne déclare pas d'entrée Analog!
    • D13 est une sortie.
  • on se fait des variables: sensorValue et outputValue
  • la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:
    • mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref
    • map: pour changer la dynamique. Indispensable ici!
    • Serial.print de chaine fixe.
    • Serial.print de variable.


TODO: pretty print source code AnalogInSerialOut

Défi  : afficher autre chose que la valeur brute?

  • Par exemple, un coffre fort? Eg si potards à la bonne valeur (voire, une suite de positions), afficher un mot de passe sur port série. Ou roulette russe avec des hints
  • Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.

Défi : serial et debug

  • 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

Envoyer des commandes et des infos à l'Arduino depuis le PC!

Exemple "SerialInAction"

Nous allons utiliser le programme d'exemple fait sur mesure SerialInAction (TODO: nommer mieux), il fait XXXX et YYYY. Le fichier du projet se trouve XXX

Le montage: TODO frizting.

Comprendre le schéma/installation: TODO rien de spécial/nouveau...? voire rien du tout: L/D13

Le code source:

  • la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:
    • on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.
    • D13 est une sortie.
  • la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:
    • vérification si données dispo avec fonction TODO ref
    • switch TODO ref pour choisir l'action selon le caractere recu.


TODO: pretty print source code custom exemple:

TODO: header comment 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 : piloter plusieurs leds

TODO texte et redécoupage.

  • exemple: pilotage RGB

Défi : piloter Fade

TODO texte et redécoupage.

  • exemple: valeurs/paramètres de fade
  • exemple: clignotements différents, eg trig de séquences

Défi : set de valeurs..?

  • 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...)
  • exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!

Microprojets: XXX

Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?

backdoor paramétrage central intersection

Pour aller plus loin

TODO texte... 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.

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!

On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)

Capteurs de température et de lumière

TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.

Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!

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.


Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.

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

Exemple : capteur de lumiere

  • schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...
  • code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.

Exemple : capteur de température

  • schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...
  • code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.


Buzzer et sons

TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.

Exemple : cri de la victoire

Code exemple de tone

Défi : morse en audio

On pourrait avoir le terminal Morse en audio plutot que sur la led.

Défi : theremine

On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.

Microservomoteur et mouvement

TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.


Exemple: swipe

analyse, comme d'hab.

Exemple: knob

analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.

Défi : trappe aération serre

capteur de température et ouverture trappe ventilation serre, hysteresis, etc.

Microprojet: poubelle intelligente

capteur de lumière/capteur de proximité => poulie, servomoteur

Microprojet: bras robot

pilotage par potards et par serial port du kit bras robot 4 axes.

Conclusion

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

  • piloter des sorties (digitales et analogiques),
  • lire l'état d'entrées (digitales et analogiques),
  • communications avec le PC (dans les deux sens)
  • capteurs et actionneurs sympa.

On a réalisé plusieurs défis et micro-projets. Quand on veut faire un projet quelconque de plus grande envergure, on fait comme cela aussi: on commence par examiner chacun des petits bouts, avant d'assembler les pièces du puzzle.

D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.

la suite

  • Assister à la formation "mon premier petit projet Arduino". L'idée est justement d'utiliser d'autres modules capteurs/actionneurs pour réaliser 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 compréhension des microcontrôleurs, 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