Formations: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!

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

 * Prérequis: aucun, à part savoir lire.
 * Idéalement:
 * notions basiques d'électronique : voir la formation à ce sujet
 * notions basiques de programmation : voir la formation à ce sujet


 * 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:
 * voir https://www.arduino.cc/en/Main/Software#
 * https://learn.sparkfun.com/tutorials/installing-arduino-ide à traduire
 * 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.

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

 * sur le site www.arduino.cc : tutoriels et surtout exemples de code avec explications
 * la page équivalente à celle-ci directement sur le site official (en moins bien, forcément ;)
 * 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.

A propos de la programmation

 * notions basiques de programmation : voir la formation à ce sujet
 * voir les elements du langage de programmation et les librairies Arduino
 * https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique
 * https://fr.wikiversity.org/wiki/Introduction_g%C3%A9n%C3%A9rale_%C3%A0_la_programmation
 * https://fr.wikiversity.org/wiki/Introduction_au_langage_C

A propos de l'electronique

 * notions basiques d'électronique : voir la formation à ce sujet
 * how to electronique: 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é = 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:
 * 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
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. TODO: pictures de partout.
 * menus (choix de carte/port, exemples)
 * boutons upload & terminal
 * fenêtre d'édition du programme

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.

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.

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): Solution primitive: on pourrait utiliser quelque chose du genre de:
 * 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é
 * 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) :

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
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?
 * 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?)

=> Qu'est ce que vous voulez apprendre de plus/approfondir?
 * Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...


 * 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