https://wiki.electrolab.fr/api.php?action=feedcontributions&user=Cl%C3%A9ment&feedformat=atomElectrolab - User contributions [en]2024-03-28T11:35:18ZUser contributionsMediaWiki 1.22.4https://wiki.electrolab.fr/Projets:Perso:TwinteethClemProjets:Perso:TwinteethClem2017-04-01T15:36:22Z<p>Clément: /* Updates */</p>
<hr />
<div>= Description =<br />
Assemblage de machine en kit: www.diyouware.com<br />
<br />
Objectifs:<br />
* avoir une petite machine opé<br />
* mieux maitriser le ldi<br />
* jouer à machinekit<br />
<br />
= Updates =<br />
<br />
== 01/04/2017 ==<br />
Quoi de mieux un 1er avril que de reprendre un projet qui n'a pas bougé depuis des mois (années) ? Au programme, voir http://www.diyouware.com/node/200. Dépouillage de cable ethernet pour récupérer 4 paires de fils signaux, et passage d'un set de 9 fils colorés (ya du rab). Passage également d'un câble avec blindage pour le signal FE. Ca donne le cablage suivant:<br />
<br />
{|class="wikitable sortable" width=100%<br />
|-<br />
! DB15 !! Wire Color !! ToolHead !! Arduino/RAMPS !! IN/OUT !! Signal Name !! Decription<br />
|-<br />
| 1 || none || Laser|| D11|| OUT || SEL1|| SEL1 and SEL2 turn on/off one of the three laser diodes (UV, Red and IR)<br />
|-<br />
| 2 || none || Laser|| D5|| OUT|| Lens servo || PWM signal for moving the focus lens.<br />
|-<br />
| 3 || none || Laser|| D6|| OUT || Laser power || PWM signal for controlling the laser diode current (and power)<br />
|-<br />
| 4 || none || Laser|| D4|| OUT|| SEL2|| SEL1 and SEL2 turn on/off one of the three laser diodes (UV, Red and IR)<br />
|-<br />
| 5 || none || Motor|| E0-1A|| OUT || Stepper 1A || Stepper motor coil 1-A.<br />
|-<br />
| 6 || none || Motor|| E0-2B || OUT || Stepper 2B || Stepper motor coil 2-B.<br />
|-<br />
| 7 || none || Motor|| E0-1B || OUT || Stepper 1B || Stepper motor coil 1-B.<br />
|-<br />
| 8 || none || Motor|| E0-2A || OUT || Stepper 2A || Stepper motor coil 2-A.<br />
|-<br />
| 9 || none || 3Dprint|| D10|| OUT|| Heater || Hot-end Heater<br />
|-<br />
| 10 || none || 3Dprint || D10|| OUT|| Heater || Hot-end Heater<br />
|-<br />
| 11 || none || Laser || N/A|| N/A|| +5V|| 5V supply from PSU<br />
|-<br />
| 12 || none || 3Dprint || T0|| IN|| Thermistance|| Hot-end Thermistance<br />
|-<br />
| 13 || none || 3Dprint || T0|| IN|| Thermistance|| Hot-end Thermistance<br />
|-<br />
| 14 || none || Laser|| AGND|| N/A|| AGND|| Pickup Driver Analog GND (FE cable shield)<br />
|-<br />
| 15 || none || Laser|| A3 || IN || FE || Focus Error signal line.<br />
|-<br />
| frame || none || Laser|| N/A|| N/A|| GND1|| digital & power GND (from PSU)<br />
|}<br />
<br />
On soude les fils coté DB15 sur le sommet de la machine.<br />
<br />
= Achats =<br />
* Kit meca: done<br />
* Kit tool: done<br />
* steppers: todo Vincent ; en attendant moteurs en stock<br />
* elec: done aliexpress ; en attendant ramps en stock<br />
* Dremel 200: en attente Conrad<br />
* Alim: en attente mouser/ATX<br />
<br />
= Steps =<br />
*Assemblage mécanique: done<br />
*Install soft: done (partiel, cf eagle & cie)<br />
*test preliminaire meca: done ok (déplacement plateforme)<br />
*Cablage:<br />
*Montage connecteur top:<br />
*montage support cam:<br />
*montage testprobe:<br />
*Calibration:<br />
*assemblage tools laserhead: PCB done, à tester<br />
*assemblage paste: done, probleme fixation stepper, reste à souder connecteur.<br />
<br />
= Issues =<br />
*Quelques updates de doc (cf pad)<br />
*jeu rods<br />
*sourcing meilleures rotules?<br />
<br />
= Furthersteps =<br />
*update rods..?<br />
*replacement elec par BBB/machinekit + replicape or cramps + machineface.<br />
*montage laserhead sur machine cartesienne à PCB<br />
*jig percage pcb de stock</div>Clémenthttps://wiki.electrolab.fr/Bemicro_Max10Bemicro Max102017-03-28T09:48:32Z<p>Clément: /* Documentation et ressources */</p>
<hr />
<div>Cette page a pour but de rassembler toutes les infos pertinentes à propos de la carte [http://company.arrow.com/bemicro/ Bemicro Max 10], dont le lab possède 8 exemplaires à disposition des membres pour leurs expérimentations avec des FPGA. Voir avec vos permanents préférés pour en emprunter une.<br />
<br />
<br />
Cette page vise à servir de portail (donc digeste) vers un ensemble de sous pages plus détaillées.<br />
<br />
= A propos de cette carte=<br />
<br />
== Description ==<br />
outline:<br />
* Description des specs<br />
* Applications/ce qu'on peut en faire<br />
* Détails sur la raison d'être au lab de cet outil<br />
<br />
== Démarrage ==<br />
outline:<br />
* Description du workflow (Quartus, QSYS)<br />
* Description des docs requises/training disponibles<br />
* installation des outils (subpage)/mise en route.<br />
<br />
= Documentation et ressources =<br />
Plusieurs liens utiles:<br />
* La page produit: https://www.altera.com/products/fpga/max-series/max-10/overview.html<br />
* La page avec tous les pointeurs de doc: https://www.altera.com/products/fpga/max-series/max-10/support.html<br />
* La page spécifique à cette board: https://www.arrow.com/en/products/bemicromax10/arrow-development-tools<br />
* La page communautaire pour cette board: http://www.alterawiki.com/wiki/BeMicro_Max_10<br />
* La playlist youtube Altera sur les MAX10: https://www.youtube.com/playlist?list=PL0pU5hg9yniYyYCX1-yXvTNiXHBhEqxpR<br />
Formations au lab:<br />
* [[Formations:FPGA:Initiation Découverte et initiation FPGA et électronique numérique]]<br />
* [http://wiki.electrolab.fr/Formation::FPGA Formation intermédiaire FPGA et logique combinatoire, HDL]<br />
<br />
= Projets =<br />
Pointeurs vers des projets ou bouts de projets intéressants liés à cette carte.</div>Clémenthttps://wiki.electrolab.fr/Bemicro_Max10Bemicro Max102017-03-28T09:26:30Z<p>Clément: /* Documentation et ressources */</p>
<hr />
<div>Cette page a pour but de rassembler toutes les infos pertinentes à propos de la carte [http://company.arrow.com/bemicro/ Bemicro Max 10], dont le lab possède 8 exemplaires à disposition des membres pour leurs expérimentations avec des FPGA. Voir avec vos permanents préférés pour en emprunter une.<br />
<br />
<br />
Cette page vise à servir de portail (donc digeste) vers un ensemble de sous pages plus détaillées.<br />
<br />
= A propos de cette carte=<br />
<br />
== Description ==<br />
outline:<br />
* Description des specs<br />
* Applications/ce qu'on peut en faire<br />
* Détails sur la raison d'être au lab de cet outil<br />
<br />
== Démarrage ==<br />
outline:<br />
* Description du workflow (Quartus, QSYS)<br />
* Description des docs requises/training disponibles<br />
* installation des outils (subpage)/mise en route.<br />
<br />
= Documentation et ressources =<br />
Plusieurs liens utiles:<br />
* La page produit: https://www.altera.com/products/fpga/max-series/max-10/overview.html<br />
* La page avec tous les pointeurs de doc: https://www.altera.com/products/fpga/max-series/max-10/support.html<br />
* La page spécifique à cette board: https://www.arrow.com/en/products/bemicromax10/arrow-development-tools<br />
* La page communautaire pour cette board: http://www.alterawiki.com/wiki/BeMicro_Max_10<br />
<br />
Formations au lab:<br />
* [[Formations:FPGA:Initiation Découverte et initiation FPGA et électronique numérique]]<br />
* [http://wiki.electrolab.fr/Formation::FPGA Formation intermédiaire FPGA et logique combinatoire, HDL]<br />
<br />
= Projets =<br />
Pointeurs vers des projets ou bouts de projets intéressants liés à cette carte.</div>Clémenthttps://wiki.electrolab.fr/Bemicro_Max10Bemicro Max102017-03-28T09:21:49Z<p>Clément: Creation page pour rassembler toutes les infos sur cette carte.</p>
<hr />
<div>Cette page a pour but de rassembler toutes les infos pertinentes à propos de la carte [http://company.arrow.com/bemicro/ Bemicro Max 10], dont le lab possède 8 exemplaires à disposition des membres pour leurs expérimentations avec des FPGA. Voir avec vos permanents préférés pour en emprunter une.<br />
<br />
<br />
Cette page vise à servir de portail (donc digeste) vers un ensemble de sous pages plus détaillées.<br />
<br />
= A propos de cette carte=<br />
<br />
== Description ==<br />
outline:<br />
* Description des specs<br />
* Applications/ce qu'on peut en faire<br />
* Détails sur la raison d'être au lab de cet outil<br />
<br />
== Démarrage ==<br />
outline:<br />
* Description du workflow (Quartus, QSYS)<br />
* Description des docs requises/training disponibles<br />
* installation des outils (subpage)/mise en route.<br />
<br />
= Documentation et ressources =<br />
Plusieurs liens utiles:<br />
* https://www.altera.com/products/fpga/max-series/max-10/overview.html<br />
* https://www.arrow.com/en/products/bemicromax10/arrow-development-tools<br />
* {wiki with schematic & empty projects, etc}<br />
<br />
Formations au lab:<br />
* [[Formations:FPGA:Initiation Découverte et initiation FPGA et électronique numérique]]<br />
* [http://wiki.electrolab.fr/Formation::FPGA Formation intermédiaire FPGA et logique combinatoire, HDL]<br />
<br />
= Projets =<br />
Pointeurs vers des projets ou bouts de projets intéressants liés à cette carte.</div>Clémenthttps://wiki.electrolab.fr/ArduinoDay2017:EnglishArduinoDay2017:English2017-03-23T13:48:32Z<p>Clément: /* Schedule */</p>
<hr />
<div>= Arduino Day 2017 =<br />
[[ArduinoDay2017| Lire ceci en francais]]<br />
<br />
Saturday april 1st, 2pm to 7pm, discover & practice Arduino at Electrolab! Get in touch: contact(at)electrolab(dot)fr<br />
<br />
== Schedule ==<br />
Details to come:<br />
*2pm/4pm: workshop for beginners, please [mailto:contact@electrolab.fr register by email] By lack of participants (zero registration so far), this workshop is cancelled<br />
*4pm/7pm: projects, hacking & chat: bring your work in progress and completed projects!<br />
<br />
== About Arduino and Arduino Day ==<br />
<br />
<br />
== About Electrolab ==<br />
Key info about this organization<br />
<br />
== Useful links ==<br />
*Arduino@Electrolab<br />
*Arduino online elsewhere</div>Clémenthttps://wiki.electrolab.fr/ArduinoDay2017ArduinoDay20172017-03-23T13:47:40Z<p>Clément: /* Le programme de la journée */</p>
<hr />
<div>= Arduino Day 2017 =<br />
[[ArduinoDay2017:English|Read this in english]]<br />
<br />
<br />
Samedi 1er avril après midi de 14h à 19h, venez découvrir et pratiquer Arduino à l'Electrolab ! Cette page rassemble toutes les informations à propos du Arduino Day 2017 à l'Electrolab. Contactez nous à contact(at)electrolab(dot)fr pour toute question.<br />
<br />
== Le programme de la journée ==<br />
Voici le programme de la journée:<br />
*14h/16h: atelier découverte pour les débutants (voir [[Formations:Arduino:Initiation|la page sur le wiki]]). Faute de participants (zéro inscrits à ce jour) cet atelier est annulé!<br />
*16h/19h: session projet, bidouille et discussion: vétéran ou débutant, Arduino est à l'honneur ! Amenez vos projets en cours ou terminés<br />
<br />
== A propos d'Electrolab ==<br />
{TODO: Informations clé sur le lieu, à (re)découvrir à cette occasion.}<br />
<br />
== Liens utiles et ressources ==<br />
*ressources Arduino@Electrolab<br />
*ressources Arduino online ailleurs<br />
*lien thread sur le forum</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:InitiationFormations:Arduino:Initiation2017-03-15T16:58:13Z<p>Clément: /* Formation Arduino: initiation */</p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Formation Arduino: initiation =<br />
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!<br />
<br />
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers Arduino. <br />
<br />
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!<br />
<br />
== TODO/meta ==<br />
* 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?<br />
* ajouter shitloads of pictures<br />
* ajouter le module spoileralert pour masquer les réponses...<br />
* schéma frizting<br />
* prettyprint sourcecode...<br />
* couper en n pages (pour les 3 troncs de contenu, les annexes?), voire préparer pour migration vers learn.electrolab.fr<br />
<br />
== Informations pratiques ==<br />
* Durée: 3h voire plus<br />
* Public visé: tous les membres, niveau débutant en programmation/électronique/Arduino<br />
<br />
== Formations liées ==<br />
*Prérequis: aucun, à part savoir lire.<br />
* Idéalement:<br />
** notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
** notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
<br />
* Formations suivantes:<br />
** Mon premier projet Arduino<br />
<br />
== Matériel requis ==<br />
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<br />
<br />
<br />
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.<br />
<br />
Contenu :<br />
* Arduino Nano + cable USB<br />
* breadboard pour prototypage et cables male/male et femelle/femelle<br />
* potentiomètre et bouton poussoir (joystick)<br />
* leds rouge, verte, jaune, blanche, bleue, RGB et résistances 330 ohm<br />
* photorésistance & thermistance + set de résistances adaptées (2x1k, 2x10k, 2x100k)<br />
* micro-servomoteur, buzzer<br />
<br />
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.<br />
<br />
=== Installation IDE ===<br />
A déplacer au bon endroit/page de référence en la matiere:<br />
* voir https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide à traduire<br />
* 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.<br />
<br />
== Ressources additionnelles ==<br />
Pour se fournir en matériel:<br />
* 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<br />
* de nombreuses enseignes vendent du matériel lié à arduino: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== A propos d'Arduino ===<br />
* 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] <br />
* [https://www.arduino.cc/en/Guide/HomePage la page équivalente à celle-ci] directement sur le site official (en moins bien, forcément ;)<br />
* [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<br />
* reference francophone: pas mal de choses bien ici: http://eskimon.fr/<br />
* explorez les sites des vendeurs de matériel type Sparkfun, Adafruit Industries, ...<br />
* ouvrages papier: à mon humble avis, "Arduino pour les nuls" est pas mal.<br />
<br />
=== A propos de la programmation ===<br />
* notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
* voir [https://www.arduino.cc/en/Reference/HomePage les elements du langage de programmation et les librairies Arduino]<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique<br />
* https://fr.wikiversity.org/wiki/Introduction_g%C3%A9n%C3%A9rale_%C3%A0_la_programmation<br />
* https://fr.wikiversity.org/wiki/Introduction_au_langage_C<br />
<br />
=== A propos de l'electronique ===<br />
* notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|sur le wiki du lab]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectromagn%C3%A9tisme_et_%C3%A9lectricit%C3%A9<br />
<br />
= Contenu détaillé =<br />
Cette formation est prevue pour être animée au lab.<br />
Il est envisageable de suivre le plan en autoformation (mais pour l'instant, cette page nécessite d'être étoffée).<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement.<br />
<br />
== Introduction ==<br />
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.<br />
<br />
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 !<br />
<br />
==== Préliminaires: notions d'électronique et d'informatique ====<br />
Pendant cette formation, nous allons manipuler:<br />
* des notions d'électronique :<br />
** électricité, tension/courant<br />
** circuit électrique, schémas et modèle<br />
* des notions d'informatique :<br />
** qu'est-ce que c'est qu'un programme? langage de programmation.<br />
** sémantique du langage et [https://www.arduino.cc/en/Reference/HomePage mots clés spécifiques Arduino].<br />
** étapes de travail: conception, écriture, compilation, tests & correctifs.<br />
<br />
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.<br />
<br />
<br />
=== Microcontrôleurs ===<br />
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<br />
<br />
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<br />
<br />
https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR<br />
<br />
<br />
==== Qu'est-ce qu'un microcontrôleur? ====<br />
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.<br />
<br />
TODO: picture d'un chip au centre d'une carte.<br />
<br />
==== Qu'est-ce qu'un microprocesseur ? ====<br />
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 :<br />
* ajouter la valeur 42 à la case mémoire #3<br />
* si la case mémoire #3 est nulle, aller exécuter l'instruction 2 cases plus bas dans la mémoire programme<br />
* sinon, exécuter celle 1 case plus bas dans la mémoire programme<br />
<br />
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.<br />
<br />
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"...<br />
<br />
==== Qu'est-ce que le binaire et le nombre de bits ? ====<br />
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.<br />
<br />
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.<br />
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 !<br />
<br />
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.<br />
<br />
<br />
Voir:<br />
* https://fr.wikiversity.org/wiki/Code_de_num%C3%A9ration/Introduction<br />
* https://fr.wikipedia.org/wiki/Virgule_fixe<br />
* https://fr.wikipedia.org/wiki/IEEE_754 (norme pour nombres à virgule: attention compliqué!)<br />
<br />
==== A quoi ca sert/où ca sert? ====<br />
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.<br />
<br />
TODO: picture synoptique système d'un objet courant simple, avec visu entrées, sorties, algorithme<br />
<br />
Par exemple: {système quelconque avec asservissement ou FSM, genre controleur de machine à laver? ou d'ascenceur?}<br />
<br />
<br />
==== Comment on s'en sert? ====<br />
* 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?<br />
* 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.<br />
* É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!<br />
* Tests, correctifs & modifications: rien ne marche jamais du premier coup...<br />
<br />
=== L'univers Arduino ===<br />
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!<br />
<br />
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.<br />
<br />
==== C'est quoi Arduino ? ====<br />
Par rapport à plein de cartes qui existaient auparavant, les gens d'Arduino ont fait plusieurs trucs géniaux:<br />
* 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.<br />
* 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.<br />
* 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.<br />
<br />
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.<br />
<br />
==== Anatomie d'une carte Arduino ====<br />
présentation de la Nano: photo, feature sheet.<br />
<br />
Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg image d'une Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png le pinout Arduino Nano]<br />
<br />
==== Fonctionnalités de notre carte Arduino ====<br />
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 :<br />
* 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.<br />
* 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..<br />
* 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).<br />
* 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 !<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Utiliser l'outil logiciel ====<br />
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.<br />
* menus (choix de carte/port, exemples)<br />
* boutons upload & terminal <br />
* fenêtre d'édition du programme<br />
TODO: pictures de partout.<br />
<br />
==== Installation des logiciels ====<br />
'''Installation/verification de l'IDE + du driver.'''<br />
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.<br />
<br />
TODO: pictures de partout.<br />
<br />
* Installation pas à pas de l'IDE<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== Le matériel ===<br />
Nous allons découvrir chacun des éléments du kit de découverte Arduino.<br />
<br />
TODO: pictures de partout ; est-ce qu'on renverrait pas vers des pages ailleurs qui contiennent ces infos?<br />
<br />
*Breadboard <br />
** Décrire comment marche une breadboard<br />
** Mises en garde/comment on fait un circuit<br />
* composant x:<br />
<br />
== Piloter des sorties ==<br />
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.<br />
<br />
=== Allumer et éteindre des LED ===<br />
<br />
==== Exemple "blink" et fonctions de base ====<br />
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.<br />
<br />
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.<br />
<br />
Cette manipulation simple représente le B.A.BA de l'utilisation de microcontrôleurs: bravo, vous venez de faire votre premier pas :)<br />
<br />
<br />
'''Le montage:'''<br />
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 ! <br />
<br />
TODO: pictures.<br />
<br />
'''Comprendre le schéma:'''<br />
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.<br />
<br />
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 !<br />
<br />
TODO: picture schematic sortie arduino resistance led.<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient quatre instructions:<br />
** on allume la led, en mettant la sortie 13 à l'état haut<br />
** on attend 1000 millisecondes, soit une seconde<br />
** on éteint la led, en mettant la sortie 13 à l'état bas<br />
** on attend 1000 millisecondes, soit une seconde<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Défi 1: changer la vitesse de clignottement ====<br />
Question: Comment on fait pour changer la vitesse à laquelle clignote la led ?<br />
<br />
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.<br />
<br />
Réponse: {masqué!}<br />
* en changeant la valeur 1000, on modifie le temps d'attente après avoir allumé ou éteint la led. Par exemple:<br />
** en mettant 200 et 200, la led clignote 5 fois plus vite<br />
** en mettant 2000 et 2000, la led clignote 2 fois plus lentement<br />
** en mettant 500 et 1500, la led clignote à la même vitesse, mais est allumée moins longtemps<br />
<br />
Résultat:<br />
* Compréhension d'un premier programme<br />
* Passage immédiat à l'action et interaction immédiate avec le sujet d'étude<br />
<br />
==== Défi 2: SOS morse ====<br />
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.<br />
<br />
Question pratique: faites donc un afficheur de SOS en morse sur la led L !<br />
<br />
Réponses: <br />
* diversité d'approches, de stratégies:<br />
** on peut faire de simples copier coller des 4 lignes de l'exemple de départ<br />
** utiliser des fonctions: créer une fonction flash_court() et une fonction flash-long(), par exemple<br />
* 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;<br />
<br />
Résultat:<br />
* on a désormais un programme un peu plus sophistiqué que le simple clignotement<br />
<br />
<br />
Questions subsidiaires:<br />
* 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"<br />
* 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).<br />
<br />
<br />
TODO: pretty print source code de ces questions subsidiaires<br />
<br />
En conclusion: même sur un exemple simple, bien structurer son programme et anticiper ce à quoi il va pouvoir servir est important.<br />
<br />
=== Allumer des LED avec intensité variable ===<br />
<br />
==== Défi 3: ultra rapide ====<br />
Question: Il se passe quoi si on fait clignoter suuuper vite?<br />
<br />
Là encore: faites le test! Mettez ''delay(100)'', puis ''delay(10)'' et ''delay(1)''.<br />
<br />
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.<br />
<br />
Question: ajuster la vitesse de clignotement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.<br />
<br />
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 !<br />
<br />
Question: ca veut dire quoi, super vite, pour le microcontrôleur?<br />
<br />
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... <br />
<br />
==== Défi 4 : jouer avec les délais ====<br />
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clémenthttps://wiki.electrolab.fr/ArduinoDay2017:EnglishArduinoDay2017:English2017-03-15T16:52:30Z<p>Clément: /* Schedule */</p>
<hr />
<div>= Arduino Day 2017 =<br />
[[ArduinoDay2017| Lire ceci en francais]]<br />
<br />
Saturday april 1st, 2pm to 7pm, discover & practice Arduino at Electrolab! Get in touch: contact(at)electrolab(dot)fr<br />
<br />
== Schedule ==<br />
Details to come:<br />
*2pm/4pm: workshop for beginners, please [mailto:contact@electrolab.fr register by email]<br />
*4pm/7pm: projects, hacking & chat: bring your work in progress and completed projects!<br />
<br />
== About Arduino and Arduino Day ==<br />
<br />
<br />
== About Electrolab ==<br />
Key info about this organization<br />
<br />
== Useful links ==<br />
*Arduino@Electrolab<br />
*Arduino online elsewhere</div>Clémenthttps://wiki.electrolab.fr/ArduinoDay2017ArduinoDay20172017-03-15T16:50:51Z<p>Clément: /* Arduino Day 2017 */</p>
<hr />
<div>= Arduino Day 2017 =<br />
[[ArduinoDay2017:English|Read this in english]]<br />
<br />
<br />
Samedi 1er avril après midi de 14h à 19h, venez découvrir et pratiquer Arduino à l'Electrolab ! Cette page rassemble toutes les informations à propos du Arduino Day 2017 à l'Electrolab. Contactez nous à contact(at)electrolab(dot)fr pour toute question.<br />
<br />
== Le programme de la journée ==<br />
Voici le programme de la journée:<br />
*14h/16h: atelier découverte pour les débutants (voir [[Formations:Arduino:Initiation|la page sur le wiki]]), [mailto:contact@electrolab.fr inscrivez vous par mail]<br />
*16h/19h: session projet, bidouille et discussion: vétéran ou débutant, Arduino est à l'honneur ! Amenez vos projets en cours ou terminés<br />
<br />
== A propos d'Electrolab ==<br />
{TODO: Informations clé sur le lieu, à (re)découvrir à cette occasion.}<br />
<br />
== Liens utiles et ressources ==<br />
*ressources Arduino@Electrolab<br />
*ressources Arduino online ailleurs<br />
*lien thread sur le forum</div>Clémenthttps://wiki.electrolab.fr/ArduinoDay2017ArduinoDay20172017-03-15T16:47:57Z<p>Clément: /* Le programme de la journée */</p>
<hr />
<div>= Arduino Day 2017 =<br />
[[ArduinoDay2017:English|Read this in english]]<br />
<br />
<br />
Samedi 1er avril après midi de 14h à 19h, venez découvrir et pratiquer Arduino à l'Electrolab ! Cette page rassemble toutes les informations à propos du Arduino Day 2017 à l'Electrolab. Contactez nous à contact(at)electrolab(dot)fr pour toute question.<br />
<br />
== Le programme de la journée ==<br />
Détails à venir:<br />
*14h/16h: atelier découverte pour les débutants (voir [[Formations:Arduino:Initiation|la page sur le wiki]]), [[mailto:contact@electrolab.fr|inscrivez vous par mail]]<br />
*16h/19h: projets, bidouilles, discussions: vétéran ou débutant, Arduino est à l'honneur !<br />
<br />
== A propos d'Arduino et de l'Arduino Day ==<br />
<br />
<br />
== A propos d'Electrolab ==<br />
Informations clé sur le lieu, à (re)découvrir à cette occasion.<br />
<br />
== Liens utiles et ressources ==<br />
*ressources Arduino@Electrolab<br />
*ressources Arduino online ailleurs</div>Clémenthttps://wiki.electrolab.fr/ArduinoDay2017:EnglishArduinoDay2017:English2017-03-02T11:19:57Z<p>Clément: /* Arduino Day 2017 */</p>
<hr />
<div>= Arduino Day 2017 =<br />
[[ArduinoDay2017| Lire ceci en francais]]<br />
<br />
Saturday april 1st, 2pm to 7pm, discover & practice Arduino at Electrolab! Get in touch: contact(at)electrolab(dot)fr<br />
<br />
== Schedule ==<br />
Details to come:<br />
*2pm: start of the event<br />
*7pm: end of the event<br />
<br />
Register by email here: contact(at)electrolab(dot)fr<br />
<br />
== About Arduino and Arduino Day ==<br />
<br />
<br />
== About Electrolab ==<br />
Key info about this organization<br />
<br />
== Useful links ==<br />
*Arduino@Electrolab<br />
*Arduino online elsewhere</div>Clémenthttps://wiki.electrolab.fr/ArduinoDay2017:EnglishArduinoDay2017:English2017-03-02T11:18:32Z<p>Clément: /* Arduino Day 2017 */</p>
<hr />
<div>= Arduino Day 2017 =<br />
[[ArduinoDay2017 Lire ceci en francais]]<br />
<br />
Saturday april 1st, 2pm to 7pm, discover & practice Arduino at Electrolab! Get in touch: contact(at)electrolab(dot)fr<br />
<br />
== Schedule ==<br />
Details to come:<br />
*2pm: start of the event<br />
*7pm: end of the event<br />
<br />
Register by email here: contact(at)electrolab(dot)fr<br />
<br />
== About Arduino and Arduino Day ==<br />
<br />
<br />
== About Electrolab ==<br />
Key info about this organization<br />
<br />
== Useful links ==<br />
*Arduino@Electrolab<br />
*Arduino online elsewhere</div>Clémenthttps://wiki.electrolab.fr/ArduinoDay2017ArduinoDay20172017-03-02T11:16:16Z<p>Clément: /* Arduino Day 2017 */</p>
<hr />
<div>= Arduino Day 2017 =<br />
[[ArduinoDay2017:English|Read this in english]]<br />
<br />
<br />
Samedi 1er avril après midi de 14h à 19h, venez découvrir et pratiquer Arduino à l'Electrolab ! Cette page rassemble toutes les informations à propos du Arduino Day 2017 à l'Electrolab. Contactez nous à contact(at)electrolab(dot)fr pour toute question.<br />
<br />
== Le programme de la journée ==<br />
Détails à venir:<br />
*14h: début<br />
*19h: fin<br />
<br />
Inscrivez vous par mail: contact(at)electrolab(dot)fr<br />
<br />
== A propos d'Arduino et de l'Arduino Day ==<br />
<br />
<br />
== A propos d'Electrolab ==<br />
Informations clé sur le lieu, à (re)découvrir à cette occasion.<br />
<br />
== Liens utiles et ressources ==<br />
*ressources Arduino@Electrolab<br />
*ressources Arduino online ailleurs</div>Clémenthttps://wiki.electrolab.fr/ArduinoDay2017:EnglishArduinoDay2017:English2017-03-02T11:14:26Z<p>Clément: Created page with "= Arduino Day 2017 = [ArduinoDay2017 Lire ceci en francais] Saturday april 1st, 2pm to 7pm, discover & practice Arduino at Electrolab! Get in touch: contact(at)electrolab(dot..."</p>
<hr />
<div>= Arduino Day 2017 =<br />
[ArduinoDay2017 Lire ceci en francais]<br />
<br />
Saturday april 1st, 2pm to 7pm, discover & practice Arduino at Electrolab! Get in touch: contact(at)electrolab(dot)fr<br />
<br />
== Schedule ==<br />
Details to come:<br />
*2pm: start of the event<br />
*7pm: end of the event<br />
<br />
Register by email here: contact(at)electrolab(dot)fr<br />
<br />
== About Arduino and Arduino Day ==<br />
<br />
<br />
== About Electrolab ==<br />
Key info about this organization<br />
<br />
== Useful links ==<br />
*Arduino@Electrolab<br />
*Arduino online elsewhere</div>Clémenthttps://wiki.electrolab.fr/ArduinoDay2017ArduinoDay20172017-03-02T11:11:20Z<p>Clément: Created page with "= Arduino Day 2017 = [ArduinoDay2017:English Read this in english] Samedi 1er avril après midi de 14h à 19h, venez découvrir et pratiquer Arduino à l'Electrolab ! Cette ..."</p>
<hr />
<div>= Arduino Day 2017 =<br />
[ArduinoDay2017:English Read this in english]<br />
<br />
<br />
Samedi 1er avril après midi de 14h à 19h, venez découvrir et pratiquer Arduino à l'Electrolab ! Cette page rassemble toutes les informations à propos du Arduino Day 2017 à l'Electrolab. Contactez nous à contact(at)electrolab(dot)fr pour toute question.<br />
<br />
== Le programme de la journée ==<br />
Détails à venir:<br />
*14h: début<br />
*19h: fin<br />
<br />
Inscrivez vous par mail: contact(at)electrolab(dot)fr<br />
<br />
== A propos d'Arduino et de l'Arduino Day ==<br />
<br />
<br />
== A propos d'Electrolab ==<br />
Informations clé sur le lieu, à (re)découvrir à cette occasion.<br />
<br />
== Liens utiles et ressources ==<br />
*ressources Arduino@Electrolab<br />
*ressources Arduino online ailleurs</div>Clémenthttps://wiki.electrolab.fr/Projets:Perso:Siege_dynamiqueProjets:Perso:Siege dynamique2017-02-27T16:20:13Z<p>Clément: /* 2 DoF 360° */</p>
<hr />
<div>'''Relance du projet par Limesle et Clem'''<br />
<br />
{{Project<br />
|name= Siège dynamique pour simulateur<br />
|author= [[User:Limesle|Limesle]]<br />
|proposal_date= 16/11/2012<br />
|abstract1=*Fabriquation d'un siège dynamique du type : [[http://www.racingfr.com/forum/index.php?showtopic=22814 Lien sur Racing.fr]]<br />
|abstract2=*Projet qui regroupe plusieurs compétences à développer : Electronique et mécanique<br />
|abstract3=*Projet qui peut fédérer d'autres membres par le plaisir<br />
|tags=dynamique, simulateur<br />
|where=à la maison<br />
|for_who= Ceux qui sont restés joueurs!<br />
|official_electrolab_project= no<br />
}}<br />
==Les buts poursuivis==<br />
#Produire un siège efficace dans sa dynamique (puissance vérins ou moteurs, réactivité etc ...)<br />
#Rester dans une enveloppe de prix raisonnable (à définir car très relatif tout ça)<br />
#Le projet doit être reproductible et donc bien documenté<br />
#La machine obtenue doit être suffisament sécure, pour le pilote comme pour les observateurs (Coupe circuit, cellule photo de franchissement ?)<br />
#Le résultat doit être adapté à différents jeux : simulation voiture et avion a minima, voire parapente et simulateur vol oiseau<br />
#Afin de permettre une bonne immersion, les périphériques et écrans devraient être solidaires du siège (ex : [[http://www.buzzmoica.fr/video/jeu-simulation-formule1-sur-verins-hydrauliques-11418 vidéo]])<br />
# autre solution : google cardboard ou Oculus Rift ou autre HTC Vive<br />
<br />
<br />
Les rubriques liées au développement seront :<br />
*La structure support<br />
*Les actionneurs<br />
*Les périphériques électroniques (Ordi et écran compris)<br />
*La carte de control<br />
*La programmation et les signaux et/ou informations émis par les jeux et à traduire en mouvement<br />
<br />
<br />
==Les informations de départ==<br />
Etat des lieux de la "science"<br />
Birdly de Somniacs [[https://www.youtube.com/watch?v=gWLHIusLWOc&t=77s]]<br />
Hypersuit de Theory [[https://www.youtube.com/watch?v=0WpB_nzeocM]]<br />
<br />
Cabine 360 [[https://www.youtube.com/watch?v=TokSLPB5_Bs]]<br />
[[https://www.xsimulator.net/community/threads/x-sim-360%C2%B0-2dof-motion-flight-pit-with-arduino-for-dcs-world.7224/]]<br />
<br />
Exemple d'écrans high tech : [[https://www.youtube.com/watch?v=xBE16eBJK6E&t=3s]]<br />
<br />
==L'électronique force feedback==<br />
Exemple 2DOS avec base simple et arduino :[[http://www.etr.fr/tutorial/1353-fabriquer-un-simulateur-pour-moins-de-450.html]]<br />
<br />
==Les softs de transfert info Jeu vers actionneurs==<br />
*[[https://www.xsimulator.net/]]<br />
*[[http://x-sim.de/forum/portal.php]]<br />
<br />
<br />
==Les actionneurs==<br />
<br />
===Vérins===<br />
Système par vérin double entrée pour avoir toutes les positions possibles.<br />
*[[Robotique:Equipement#Verrin|Les vérins pneumatiques en robotique]]<br />
*[[http://fr.wikipedia.org/wiki/V%C3%A9rin Vérins sur Wikipédia]]<br />
*[[http://www.festo.com/cms/fr_fr/index.htm FESTO]]<br />
<br />
Exemple à vérin pneumatiques<br />
<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques :<br />
<br />
===Moteurs Pas à Pas===<br />
<br />
===Gyroscopes===<br />
<br />
= Les différents types de machines =<br />
<br />
== Types de plateforme ==<br />
=== 2 DoF ===<br />
<br />
=== 3 DoF ===<br />
<br />
== Type rotations ==<br />
=== 2 DoF Joyrider ===<br />
<br />
=== 2 DoF 360° ===<br />
Exemple du R360 de SEGA, à 2 axes en révolution complète:<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques : [[http://www.gameroomrepair.com/R360/R360.htm]] et [[http://www.system16.com/hardware.php?id=844]]<br />
<br />
Exemple de copies chinoises:<br />
*https://www.youtube.com/watch?v=TokSLPB5_Bs<br />
*https://www.youtube.com/watch?v=1GAdDO1ik5A<br />
<br />
Bon, euh... non, passons sous silence: https://www.youtube.com/watch?v=vjOgq0_gHwg<br />
<br />
<br />
Les russes (?) aussi en ont fait:<br />
* http://kb-tk.ru/production/fly-motion.html<br />
* https://www.youtube.com/watch?v=RN1r76NLqEY<br />
* ils le vendent 20.000€<br />
<br />
<br />
A noter: contrairement au joyrider, l'axe "facile" est le roll, pas le pitch. Peut être qu'on peut vouloir faire une structure 360° avec la cinématique de joyrider...<br />
<br />
<br />
A priori l'une des machines les plus compliquées à fabriquer, de par les contraintes... une bonne approche est probablement de fabriquer d'abord une maquette, comme [ref].<br />
<br />
<br />
==== Dimensionnement mécanique ====<br />
WARNING: je suis électronicien. Tout ce qui suit est probablement archi faux et rempli de conneries: merci de critiquer de manière constructive.<br />
<br />
<br />
Plusieurs approches sont envisageables pour la fabrication: tube acier carré soudé, profilé alu avec assemblage (peut être préférable). Afin de dimensionner de la mécanique/se faire une petite idée, voici un premier crobar très grossier:<br />
* [insert pic}<br />
<br />
Comme on le voit, le tout est constitué de trois modules:<br />
* une structure, liée au sol<br />
* un bras, entrainé en rotation<br />
* une cabine<br />
<br />
===== Version poutres acier =====<br />
RAPPEL: ce qui suit est hautement théorique et probablement faux.<br />
<br />
<br />
Pour les masses, considérons ce qu'il faut comme longueur de tube par module:<br />
* Cabine: 20m de tube<br />
* Bras: 5m de tube<br />
* Structure: 12m de tube<br />
<br />
On peut du coup faire une estimation du poids de chacun des modules:<br />
* Masse tube Acier 50x50x3: 4,8kg/m (8000x50x4*3/1000000000)<br />
* Cabine: 250kg<br />
** 100kg tubes<br />
** 15kg siege<br />
** 100kg personne<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Bras:85kg<br />
** 50kg tubes (1m compte pour 2m, car tube plus gros)<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Structure: 275kg<br />
** 240kg tubes (1m compte pour 4m, car tube plus gros)<br />
** 15kg motorisation<br />
** 20kg materiel<br />
<br />
On obtient une masse totale pour la version tube acier d'environ 600kg<br />
<br />
On peut du coup s'essayer à des calculs et estimation de Résistance Des Matériaux. C'est vraiment pour le fun, parce que j'y connais rien ! Saint Wikipedia, priez pour moi !<br />
* http://fr.wikipedia.org/wiki/Th%C3%A9orie_des_poutres<br />
* http://fr.wikipedia.org/wiki/Fl%C3%A8che_%28r%C3%A9sistance_des_mat%C3%A9riaux%29<br />
* fleche = -FxL^3/(3EI) (unités ?)<br />
* http://fr.wikipedia.org/wiki/Module_d%27inertie<br />
** I_50x50x3 = (0.050^4-0.044^4)/12 = 2.08 10^-7 m^4<br />
** I_100x100x3 = (0.100^4-0.094^4)/12 = 1.83 10^-6 m^4<br />
** I_200x200x3 = (0.200^4-0.194^4)/12 = 1.53 10^-5 m^4<br />
* http://fr.wikipedia.org/wiki/Module_de_Young#Quelques_valeurs_num.C3.A9riques_de_modules_de_Young<br />
** E_Acier = 210 (GPa..? http://www.translatorscafe.com/cafe/EN/units-converter/pressure/5-20/gigapascal-newton%2Fmillimeter%C2%B2/ ?) => 2,1 x 10^11 N/m²<br />
<br />
Et c'est parti pour l'application numérique:<br />
* RDM de la nacelle:<br />
** 50x50x3mm de section, acier.<br />
** longerons: L=0.5m, 100/2kg (500N)<br />
** fleche = 0.47mm....? (d'après ma feuille de calcul excel)<br />
* RDM Bras:<br />
** jonction nacelle/bras: poutre extremité L=0.8m, masse statique 250/2kg (1200N)<br />
** similaire pour l'autre troncon de poutre (axe structure/bras vers angle bras).<br />
** 100x100x3mm de section, acier.<br />
** fleche = 0.53mm ...? (d'après ma feuille de calcul excel)<br />
* RDM structure:<br />
** L=0.5 (jusqu'à triangle de soutien), masse statique = 350kg (3500N)<br />
** 200x200x3mm de section, acier.<br />
** fleche = 0.05 mm...? (d'après ma feuille de calcul excel)<br />
<br />
Pour ce que valent ces quelques calculs, les sections 50x50x3 et 100x100x3 sont bien, la 200x200x3 est un peu overkill ;) En prenant les meme longueurs, mais avec du 100x100 on revient à une fleche de 0.38mm sur la structure... Peut être qu'il faut vérifier ces calculs et refaire avec des poutres en profilé alu (qu'on peut choisir avec une résistance similaire à ces poutres acier).<br />
<br />
===== Version poutres profilé alu =====<br />
A faire, en prenant des poutres à la résistance similaire aux versions acier, comme point de départ?<br />
* I_Acier_50x50_3 : 20.8 cm^4<br />
* I_Acier_100x100_3 : 183 cm^4<br />
* E_Acier: 210 Gpa<br />
* E_Alu: 69 Gpa<br />
Du coup, il faudrait (pour les même fleches et masses):<br />
* Alu remplacement du 50x50x3: 63.30 cm^4<br />
* Alu remplacement du 100x100x3: 557 cm^4<br />
<br />
<br />
Chez motedis, on trouve plein de choses:<br />
* Profile 40x40L I-Type slot 8 (section carrée 40x40mm)<br />
** masse: 1.74kg/m<br />
** moment x/y: 9 cm^4<br />
** 9 €/m<br />
** => clairement trop petit, sauf ptet pour des sous sections...<br />
<br />
* Profile (section rectangle 40x80mm)<br />
** masse: 3.04kg/m<br />
** moment 16 et 69cm^4<br />
** 16€/m<br />
** => Semble pas mal pour remplacement 50x50x3!<br />
<br />
* Profile 80x80<br />
** masse: 5.34kg/m<br />
** moment 135cm^4<br />
** 30€/m<br />
** => intermédiaire...<br />
<br />
<br />
* Profile 40x120L I-Type slot 8<br />
** masse: 4.35kg/m<br />
** moment 24 et 220cm^4<br />
** 25€/m<br />
** => intermédiaire...<br />
<br />
* Profile 40x160L I-Type slot 8 (section rectangle 40x160mm)<br />
** masse: 5.6kg/m<br />
** moment 30 et 500cm^4<br />
** 35€/m<br />
** => remplace le 100x100x3...<br />
<br />
<br />
On peut refaire les calculs, avec les même hypothèses, entre parenthèses les masses pour acier:<br />
* Cabine: 20m de profilé 40x40 à 9€/m => 180 €<br />
* Bras: 5m de profilé 40*80 à 16€/m => 80€<br />
* Structure: 12m de profilé 40*160 à 35€/m => 420€<br />
<br />
* Cabine: (250kg)<br />
** 35kg profilé (100kg tubes)<br />
** 15kg siege<br />
** 100kg personne<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Bras: (85kg)<br />
** 15kg (50kg tubes acier)<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Structure: (275kg)<br />
** 67 (240kg tubes)<br />
** 15kg motorisation<br />
** 20kg materiel<br />
<br />
On obtient une masse totale pour la version profilé alu réduite d'environ 65+35+173=273, pratiquement divisé par deux. Peut être qu'on peut même prendre des profilés 'intermédiaires' tout en ayant une flèche faible, par exemple structure en 80x80.<br />
<br />
===== Dimensionnement moteur =====<br />
RAPPEL: ce qui suit est hautement théorique et probablement faux.<br />
<br />
Il nous faut modéliser même grossièrement l'ensemble, et en particulier, trouver un moment d'inertie sur chaque axe pour pouvoir calculer l'accélération angulaire pour un couple moteur donné. Pas facile à modéliser quand on est noob, mais disons:<br />
* pour la nacelle, une boule de 250kg et 1m de diametre => 2/5 * 250 * 1 = 100 kg/m²<br />
* pour l'ensemble bras/nacelle, une boulle de 350 kg et 1.5m de diametre => 2/5 * 350 * 1.5² = 315 kg/m²<br />
Tout ceci est tout à fait arbitraire, mais dans l'idée, vu la répartition des masses, ce sera OK en première approche/pour un ordre de grandeur.<br />
<br />
Calculons maintenant le couple moteur requis sur chaque axe:<br />
* En regardant les servomoteurs industriels sur Aliexpress (aux alentours de 1kW), on voit qu'ils ont un couple nominal aux alentours de 5N.m à 3000rpm.<br />
* un réducteur 1:30 (qui passe le couple) donne presque 2 tours/seconde (quand même...), probablement qu'il faut au moins cette réduction, et donc le couple min sera de 150N.m (je néglige les pertes).<br />
* un réducteur 1:100 donne 2s pour faire un tour, encore respectable, et un couple de 500N.m (!)<br />
<br />
Petit retour à saint wikipedia pour calculer l'accélération angulaire, avec la formule J dw = M :<br />
* 100 kg/m² * dw rad/s² = 150 Nm => 1.5 rad/s² => 86 °/s², 8 secondes pour vmax<br />
* 315 kg/m² * dw rad/s² = 150 Nm => 0.48 rad/s² => 27 °/s², 25 secondes pour vmax<br />
* 100 kg/m² * dw rad/s² = 500 Nm => 5 rad/s² => 286 °/s², moins d'1 seconde pour vmax<br />
* 315 kg/m² * dw rad/s² = 500 Nm => 1.59 rad/s² => 91 °/s², 2 secondes pour vmax<br />
<br />
Probablement qu'une réduction plus proche de 100:1 est appropriée... ou bien un couple nominal encore plus important (eg 2kW sur l'axe bras?).<br />
Type de pièces:<br />
* SErvomotor 1kW: https://fr.aliexpress.com/item/1SET-AC-SERVO-MOTOR-DRIVER-SYSTEM-4N-M-1KW-2500RPM-90ST-AC-SERVO-MOTOR-90ST-M04025/32355566171.html?spm=2114.06010108.3.2.TqQNxi&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=7f665025-eb17-4db3-a67d-ab7f25b27590&algo_expid=0c727d85-513a-44f4-b2c8-695440ce9c04-0&algo_pvid=0c727d85-513a-44f4-b2c8-695440ce9c04<br />
* Reducteur (à vérifier la bride d'entrée!) https://fr.aliexpress.com/item/Bonfiglioli-Like-NMRV063-Worm-Wheel-Drive-Transmission-Gearbox-for-Ceramic-Industry/762259147.html?spm=2114.06010108.3.17.vyDUB4&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=ba79f59c-f6da-4075-a8a9-28b61a1a74ce&algo_expid=01b65d70-8ca2-42d3-927f-1acb226b6c58-1&algo_pvid=01b65d70-8ca2-42d3-927f-1acb226b6c58 => 7.5 à 100<br />
* Servo 2kW + Frein à manque de courant (peut être que frein c'est pas con...) https://fr.aliexpress.com/item/Delta-2KW-AC-Servo-Drive-and-Motor-ASD-A2-2023-L-ECMA-E11320SS-Brand-New-and/1108352617.html?spm=2114.06010108.3.2.sIa8NG&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=cb7b4097-596c-4793-beb9-7bfd3ac3f45a&algo_expid=b2521d12-9eca-46ee-b66d-5247b958fc22-0&algo_pvid=b2521d12-9eca-46ee-b66d-5247b958fc22<br />
* Note: moteurs 120w DC pour plateforme: https://fr.aliexpress.com/item/5D120GN-RV30-DC12V-24V-120W-1800rpm-DC-gear-motor-worm-gear-gearbox-high-torque-gear-motor/32754119224.html?spm=2114.06010108.3.85.EfcagF&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=9b90cc22-cbe4-4892-a639-5f1d0ab4da7d&algo_expid=9475ebd0-9b07-4cde-8c6f-4e73565279d0-11&algo_pvid=9475ebd0-9b07-4cde-8c6f-4e73565279d0</div>Clémenthttps://wiki.electrolab.fr/Projets:Perso:Siege_dynamiqueProjets:Perso:Siege dynamique2017-02-27T15:45:02Z<p>Clément: /* Version poutres profilé alu */</p>
<hr />
<div>'''Relance du projet par Limesle et Clem'''<br />
<br />
{{Project<br />
|name= Siège dynamique pour simulateur<br />
|author= [[User:Limesle|Limesle]]<br />
|proposal_date= 16/11/2012<br />
|abstract1=*Fabriquation d'un siège dynamique du type : [[http://www.racingfr.com/forum/index.php?showtopic=22814 Lien sur Racing.fr]]<br />
|abstract2=*Projet qui regroupe plusieurs compétences à développer : Electronique et mécanique<br />
|abstract3=*Projet qui peut fédérer d'autres membres par le plaisir<br />
|tags=dynamique, simulateur<br />
|where=à la maison<br />
|for_who= Ceux qui sont restés joueurs!<br />
|official_electrolab_project= no<br />
}}<br />
==Les buts poursuivis==<br />
#Produire un siège efficace dans sa dynamique (puissance vérins ou moteurs, réactivité etc ...)<br />
#Rester dans une enveloppe de prix raisonnable (à définir car très relatif tout ça)<br />
#Le projet doit être reproductible et donc bien documenté<br />
#La machine obtenue doit être suffisament sécure, pour le pilote comme pour les observateurs (Coupe circuit, cellule photo de franchissement ?)<br />
#Le résultat doit être adapté à différents jeux : simulation voiture et avion a minima, voire parapente et simulateur vol oiseau<br />
#Afin de permettre une bonne immersion, les périphériques et écrans devraient être solidaires du siège (ex : [[http://www.buzzmoica.fr/video/jeu-simulation-formule1-sur-verins-hydrauliques-11418 vidéo]])<br />
# autre solution : google cardboard ou Oculus Rift ou autre HTC Vive<br />
<br />
<br />
Les rubriques liées au développement seront :<br />
*La structure support<br />
*Les actionneurs<br />
*Les périphériques électroniques (Ordi et écran compris)<br />
*La carte de control<br />
*La programmation et les signaux et/ou informations émis par les jeux et à traduire en mouvement<br />
<br />
<br />
==Les informations de départ==<br />
Etat des lieux de la "science"<br />
Birdly de Somniacs [[https://www.youtube.com/watch?v=gWLHIusLWOc&t=77s]]<br />
Hypersuit de Theory [[https://www.youtube.com/watch?v=0WpB_nzeocM]]<br />
<br />
Cabine 360 [[https://www.youtube.com/watch?v=TokSLPB5_Bs]]<br />
[[https://www.xsimulator.net/community/threads/x-sim-360%C2%B0-2dof-motion-flight-pit-with-arduino-for-dcs-world.7224/]]<br />
<br />
Exemple d'écrans high tech : [[https://www.youtube.com/watch?v=xBE16eBJK6E&t=3s]]<br />
<br />
==L'électronique force feedback==<br />
Exemple 2DOS avec base simple et arduino :[[http://www.etr.fr/tutorial/1353-fabriquer-un-simulateur-pour-moins-de-450.html]]<br />
<br />
==Les softs de transfert info Jeu vers actionneurs==<br />
*[[https://www.xsimulator.net/]]<br />
*[[http://x-sim.de/forum/portal.php]]<br />
<br />
<br />
==Les actionneurs==<br />
<br />
===Vérins===<br />
Système par vérin double entrée pour avoir toutes les positions possibles.<br />
*[[Robotique:Equipement#Verrin|Les vérins pneumatiques en robotique]]<br />
*[[http://fr.wikipedia.org/wiki/V%C3%A9rin Vérins sur Wikipédia]]<br />
*[[http://www.festo.com/cms/fr_fr/index.htm FESTO]]<br />
<br />
Exemple à vérin pneumatiques<br />
<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques :<br />
<br />
===Moteurs Pas à Pas===<br />
<br />
===Gyroscopes===<br />
<br />
= Les différents types de machines =<br />
<br />
== Types de plateforme ==<br />
=== 2 DoF ===<br />
<br />
=== 3 DoF ===<br />
<br />
== Type rotations ==<br />
=== 2 DoF Joyrider ===<br />
<br />
=== 2 DoF 360° ===<br />
Exemple du R360 de SEGA, à 2 axes en révolution complète:<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques : [[http://www.gameroomrepair.com/R360/R360.htm]] et [[http://www.system16.com/hardware.php?id=844]]<br />
<br />
Exemple de copies chinoises:<br />
*{ref]<br />
*{ref]<br />
*{ref]<br />
<br />
<br />
A priori l'une des machines les plus compliquées à fabriquer, de par les contraintes... une bonne approche est probablement de fabriquer d'abord une maquette, comme [ref].<br />
<br />
<br />
==== Dimensionnement mécanique ====<br />
WARNING: je suis électronicien. Tout ce qui suit est probablement archi faux et rempli de conneries: merci de critiquer de manière constructive.<br />
<br />
<br />
Plusieurs approches sont envisageables pour la fabrication: tube acier carré soudé, profilé alu avec assemblage (peut être préférable). Afin de dimensionner de la mécanique/se faire une petite idée, voici un premier crobar très grossier:<br />
* [insert pic}<br />
<br />
Comme on le voit, le tout est constitué de trois modules:<br />
* une structure, liée au sol<br />
* un bras, entrainé en rotation<br />
* une cabine<br />
<br />
===== Version poutres acier =====<br />
RAPPEL: ce qui suit est hautement théorique et probablement faux.<br />
<br />
<br />
Pour les masses, considérons ce qu'il faut comme longueur de tube par module:<br />
* Cabine: 20m de tube<br />
* Bras: 5m de tube<br />
* Structure: 12m de tube<br />
<br />
On peut du coup faire une estimation du poids de chacun des modules:<br />
* Masse tube Acier 50x50x3: 4,8kg/m (8000x50x4*3/1000000000)<br />
* Cabine: 250kg<br />
** 100kg tubes<br />
** 15kg siege<br />
** 100kg personne<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Bras:85kg<br />
** 50kg tubes (1m compte pour 2m, car tube plus gros)<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Structure: 275kg<br />
** 240kg tubes (1m compte pour 4m, car tube plus gros)<br />
** 15kg motorisation<br />
** 20kg materiel<br />
<br />
On obtient une masse totale pour la version tube acier d'environ 600kg<br />
<br />
On peut du coup s'essayer à des calculs et estimation de Résistance Des Matériaux. C'est vraiment pour le fun, parce que j'y connais rien ! Saint Wikipedia, priez pour moi !<br />
* http://fr.wikipedia.org/wiki/Th%C3%A9orie_des_poutres<br />
* http://fr.wikipedia.org/wiki/Fl%C3%A8che_%28r%C3%A9sistance_des_mat%C3%A9riaux%29<br />
* fleche = -FxL^3/(3EI) (unités ?)<br />
* http://fr.wikipedia.org/wiki/Module_d%27inertie<br />
** I_50x50x3 = (0.050^4-0.044^4)/12 = 2.08 10^-7 m^4<br />
** I_100x100x3 = (0.100^4-0.094^4)/12 = 1.83 10^-6 m^4<br />
** I_200x200x3 = (0.200^4-0.194^4)/12 = 1.53 10^-5 m^4<br />
* http://fr.wikipedia.org/wiki/Module_de_Young#Quelques_valeurs_num.C3.A9riques_de_modules_de_Young<br />
** E_Acier = 210 (GPa..? http://www.translatorscafe.com/cafe/EN/units-converter/pressure/5-20/gigapascal-newton%2Fmillimeter%C2%B2/ ?) => 2,1 x 10^11 N/m²<br />
<br />
Et c'est parti pour l'application numérique:<br />
* RDM de la nacelle:<br />
** 50x50x3mm de section, acier.<br />
** longerons: L=0.5m, 100/2kg (500N)<br />
** fleche = 0.47mm....? (d'après ma feuille de calcul excel)<br />
* RDM Bras:<br />
** jonction nacelle/bras: poutre extremité L=0.8m, masse statique 250/2kg (1200N)<br />
** similaire pour l'autre troncon de poutre (axe structure/bras vers angle bras).<br />
** 100x100x3mm de section, acier.<br />
** fleche = 0.53mm ...? (d'après ma feuille de calcul excel)<br />
* RDM structure:<br />
** L=0.5 (jusqu'à triangle de soutien), masse statique = 350kg (3500N)<br />
** 200x200x3mm de section, acier.<br />
** fleche = 0.05 mm...? (d'après ma feuille de calcul excel)<br />
<br />
Pour ce que valent ces quelques calculs, les sections 50x50x3 et 100x100x3 sont bien, la 200x200x3 est un peu overkill ;) En prenant les meme longueurs, mais avec du 100x100 on revient à une fleche de 0.38mm sur la structure... Peut être qu'il faut vérifier ces calculs et refaire avec des poutres en profilé alu (qu'on peut choisir avec une résistance similaire à ces poutres acier).<br />
<br />
===== Version poutres profilé alu =====<br />
A faire, en prenant des poutres à la résistance similaire aux versions acier, comme point de départ?<br />
* I_Acier_50x50_3 : 20.8 cm^4<br />
* I_Acier_100x100_3 : 183 cm^4<br />
* E_Acier: 210 Gpa<br />
* E_Alu: 69 Gpa<br />
Du coup, il faudrait (pour les même fleches et masses):<br />
* Alu remplacement du 50x50x3: 63.30 cm^4<br />
* Alu remplacement du 100x100x3: 557 cm^4<br />
<br />
<br />
Chez motedis, on trouve plein de choses:<br />
* Profile 40x40L I-Type slot 8 (section carrée 40x40mm)<br />
** masse: 1.74kg/m<br />
** moment x/y: 9 cm^4<br />
** 9 €/m<br />
** => clairement trop petit, sauf ptet pour des sous sections...<br />
<br />
* Profile (section rectangle 40x80mm)<br />
** masse: 3.04kg/m<br />
** moment 16 et 69cm^4<br />
** 16€/m<br />
** => Semble pas mal pour remplacement 50x50x3!<br />
<br />
* Profile 80x80<br />
** masse: 5.34kg/m<br />
** moment 135cm^4<br />
** 30€/m<br />
** => intermédiaire...<br />
<br />
<br />
* Profile 40x120L I-Type slot 8<br />
** masse: 4.35kg/m<br />
** moment 24 et 220cm^4<br />
** 25€/m<br />
** => intermédiaire...<br />
<br />
* Profile 40x160L I-Type slot 8 (section rectangle 40x160mm)<br />
** masse: 5.6kg/m<br />
** moment 30 et 500cm^4<br />
** 35€/m<br />
** => remplace le 100x100x3...<br />
<br />
<br />
On peut refaire les calculs, avec les même hypothèses, entre parenthèses les masses pour acier:<br />
* Cabine: 20m de profilé 40x40 à 9€/m => 180 €<br />
* Bras: 5m de profilé 40*80 à 16€/m => 80€<br />
* Structure: 12m de profilé 40*160 à 35€/m => 420€<br />
<br />
* Cabine: (250kg)<br />
** 35kg profilé (100kg tubes)<br />
** 15kg siege<br />
** 100kg personne<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Bras: (85kg)<br />
** 15kg (50kg tubes acier)<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Structure: (275kg)<br />
** 67 (240kg tubes)<br />
** 15kg motorisation<br />
** 20kg materiel<br />
<br />
On obtient une masse totale pour la version profilé alu réduite d'environ 65+35+173=273, pratiquement divisé par deux. Peut être qu'on peut même prendre des profilés 'intermédiaires' tout en ayant une flèche faible, par exemple structure en 80x80.<br />
<br />
===== Dimensionnement moteur =====<br />
RAPPEL: ce qui suit est hautement théorique et probablement faux.<br />
<br />
Il nous faut modéliser même grossièrement l'ensemble, et en particulier, trouver un moment d'inertie sur chaque axe pour pouvoir calculer l'accélération angulaire pour un couple moteur donné. Pas facile à modéliser quand on est noob, mais disons:<br />
* pour la nacelle, une boule de 250kg et 1m de diametre => 2/5 * 250 * 1 = 100 kg/m²<br />
* pour l'ensemble bras/nacelle, une boulle de 350 kg et 1.5m de diametre => 2/5 * 350 * 1.5² = 315 kg/m²<br />
Tout ceci est tout à fait arbitraire, mais dans l'idée, vu la répartition des masses, ce sera OK en première approche/pour un ordre de grandeur.<br />
<br />
Calculons maintenant le couple moteur requis sur chaque axe:<br />
* En regardant les servomoteurs industriels sur Aliexpress (aux alentours de 1kW), on voit qu'ils ont un couple nominal aux alentours de 5N.m à 3000rpm.<br />
* un réducteur 1:30 (qui passe le couple) donne presque 2 tours/seconde (quand même...), probablement qu'il faut au moins cette réduction, et donc le couple min sera de 150N.m (je néglige les pertes).<br />
* un réducteur 1:100 donne 2s pour faire un tour, encore respectable, et un couple de 500N.m (!)<br />
<br />
Petit retour à saint wikipedia pour calculer l'accélération angulaire, avec la formule J dw = M :<br />
* 100 kg/m² * dw rad/s² = 150 Nm => 1.5 rad/s² => 86 °/s², 8 secondes pour vmax<br />
* 315 kg/m² * dw rad/s² = 150 Nm => 0.48 rad/s² => 27 °/s², 25 secondes pour vmax<br />
* 100 kg/m² * dw rad/s² = 500 Nm => 5 rad/s² => 286 °/s², moins d'1 seconde pour vmax<br />
* 315 kg/m² * dw rad/s² = 500 Nm => 1.59 rad/s² => 91 °/s², 2 secondes pour vmax<br />
<br />
Probablement qu'une réduction plus proche de 100:1 est appropriée... ou bien un couple nominal encore plus important (eg 2kW sur l'axe bras?).<br />
Type de pièces:<br />
* SErvomotor 1kW: https://fr.aliexpress.com/item/1SET-AC-SERVO-MOTOR-DRIVER-SYSTEM-4N-M-1KW-2500RPM-90ST-AC-SERVO-MOTOR-90ST-M04025/32355566171.html?spm=2114.06010108.3.2.TqQNxi&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=7f665025-eb17-4db3-a67d-ab7f25b27590&algo_expid=0c727d85-513a-44f4-b2c8-695440ce9c04-0&algo_pvid=0c727d85-513a-44f4-b2c8-695440ce9c04<br />
* Reducteur (à vérifier la bride d'entrée!) https://fr.aliexpress.com/item/Bonfiglioli-Like-NMRV063-Worm-Wheel-Drive-Transmission-Gearbox-for-Ceramic-Industry/762259147.html?spm=2114.06010108.3.17.vyDUB4&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=ba79f59c-f6da-4075-a8a9-28b61a1a74ce&algo_expid=01b65d70-8ca2-42d3-927f-1acb226b6c58-1&algo_pvid=01b65d70-8ca2-42d3-927f-1acb226b6c58 => 7.5 à 100<br />
* Servo 2kW + Frein à manque de courant (peut être que frein c'est pas con...) https://fr.aliexpress.com/item/Delta-2KW-AC-Servo-Drive-and-Motor-ASD-A2-2023-L-ECMA-E11320SS-Brand-New-and/1108352617.html?spm=2114.06010108.3.2.sIa8NG&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=cb7b4097-596c-4793-beb9-7bfd3ac3f45a&algo_expid=b2521d12-9eca-46ee-b66d-5247b958fc22-0&algo_pvid=b2521d12-9eca-46ee-b66d-5247b958fc22<br />
* Note: moteurs 120w DC pour plateforme: https://fr.aliexpress.com/item/5D120GN-RV30-DC12V-24V-120W-1800rpm-DC-gear-motor-worm-gear-gearbox-high-torque-gear-motor/32754119224.html?spm=2114.06010108.3.85.EfcagF&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=9b90cc22-cbe4-4892-a639-5f1d0ab4da7d&algo_expid=9475ebd0-9b07-4cde-8c6f-4e73565279d0-11&algo_pvid=9475ebd0-9b07-4cde-8c6f-4e73565279d0</div>Clémenthttps://wiki.electrolab.fr/Projets:Perso:Siege_dynamiqueProjets:Perso:Siege dynamique2017-02-27T15:33:51Z<p>Clément: /* Version poutres profilé alu */</p>
<hr />
<div>'''Relance du projet par Limesle et Clem'''<br />
<br />
{{Project<br />
|name= Siège dynamique pour simulateur<br />
|author= [[User:Limesle|Limesle]]<br />
|proposal_date= 16/11/2012<br />
|abstract1=*Fabriquation d'un siège dynamique du type : [[http://www.racingfr.com/forum/index.php?showtopic=22814 Lien sur Racing.fr]]<br />
|abstract2=*Projet qui regroupe plusieurs compétences à développer : Electronique et mécanique<br />
|abstract3=*Projet qui peut fédérer d'autres membres par le plaisir<br />
|tags=dynamique, simulateur<br />
|where=à la maison<br />
|for_who= Ceux qui sont restés joueurs!<br />
|official_electrolab_project= no<br />
}}<br />
==Les buts poursuivis==<br />
#Produire un siège efficace dans sa dynamique (puissance vérins ou moteurs, réactivité etc ...)<br />
#Rester dans une enveloppe de prix raisonnable (à définir car très relatif tout ça)<br />
#Le projet doit être reproductible et donc bien documenté<br />
#La machine obtenue doit être suffisament sécure, pour le pilote comme pour les observateurs (Coupe circuit, cellule photo de franchissement ?)<br />
#Le résultat doit être adapté à différents jeux : simulation voiture et avion a minima, voire parapente et simulateur vol oiseau<br />
#Afin de permettre une bonne immersion, les périphériques et écrans devraient être solidaires du siège (ex : [[http://www.buzzmoica.fr/video/jeu-simulation-formule1-sur-verins-hydrauliques-11418 vidéo]])<br />
# autre solution : google cardboard ou Oculus Rift ou autre HTC Vive<br />
<br />
<br />
Les rubriques liées au développement seront :<br />
*La structure support<br />
*Les actionneurs<br />
*Les périphériques électroniques (Ordi et écran compris)<br />
*La carte de control<br />
*La programmation et les signaux et/ou informations émis par les jeux et à traduire en mouvement<br />
<br />
<br />
==Les informations de départ==<br />
Etat des lieux de la "science"<br />
Birdly de Somniacs [[https://www.youtube.com/watch?v=gWLHIusLWOc&t=77s]]<br />
Hypersuit de Theory [[https://www.youtube.com/watch?v=0WpB_nzeocM]]<br />
<br />
Cabine 360 [[https://www.youtube.com/watch?v=TokSLPB5_Bs]]<br />
[[https://www.xsimulator.net/community/threads/x-sim-360%C2%B0-2dof-motion-flight-pit-with-arduino-for-dcs-world.7224/]]<br />
<br />
Exemple d'écrans high tech : [[https://www.youtube.com/watch?v=xBE16eBJK6E&t=3s]]<br />
<br />
==L'électronique force feedback==<br />
Exemple 2DOS avec base simple et arduino :[[http://www.etr.fr/tutorial/1353-fabriquer-un-simulateur-pour-moins-de-450.html]]<br />
<br />
==Les softs de transfert info Jeu vers actionneurs==<br />
*[[https://www.xsimulator.net/]]<br />
*[[http://x-sim.de/forum/portal.php]]<br />
<br />
<br />
==Les actionneurs==<br />
<br />
===Vérins===<br />
Système par vérin double entrée pour avoir toutes les positions possibles.<br />
*[[Robotique:Equipement#Verrin|Les vérins pneumatiques en robotique]]<br />
*[[http://fr.wikipedia.org/wiki/V%C3%A9rin Vérins sur Wikipédia]]<br />
*[[http://www.festo.com/cms/fr_fr/index.htm FESTO]]<br />
<br />
Exemple à vérin pneumatiques<br />
<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques :<br />
<br />
===Moteurs Pas à Pas===<br />
<br />
===Gyroscopes===<br />
<br />
= Les différents types de machines =<br />
<br />
== Types de plateforme ==<br />
=== 2 DoF ===<br />
<br />
=== 3 DoF ===<br />
<br />
== Type rotations ==<br />
=== 2 DoF Joyrider ===<br />
<br />
=== 2 DoF 360° ===<br />
Exemple du R360 de SEGA, à 2 axes en révolution complète:<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques : [[http://www.gameroomrepair.com/R360/R360.htm]] et [[http://www.system16.com/hardware.php?id=844]]<br />
<br />
Exemple de copies chinoises:<br />
*{ref]<br />
*{ref]<br />
*{ref]<br />
<br />
<br />
A priori l'une des machines les plus compliquées à fabriquer, de par les contraintes... une bonne approche est probablement de fabriquer d'abord une maquette, comme [ref].<br />
<br />
<br />
==== Dimensionnement mécanique ====<br />
WARNING: je suis électronicien. Tout ce qui suit est probablement archi faux et rempli de conneries: merci de critiquer de manière constructive.<br />
<br />
<br />
Plusieurs approches sont envisageables pour la fabrication: tube acier carré soudé, profilé alu avec assemblage (peut être préférable). Afin de dimensionner de la mécanique/se faire une petite idée, voici un premier crobar très grossier:<br />
* [insert pic}<br />
<br />
Comme on le voit, le tout est constitué de trois modules:<br />
* une structure, liée au sol<br />
* un bras, entrainé en rotation<br />
* une cabine<br />
<br />
===== Version poutres acier =====<br />
RAPPEL: ce qui suit est hautement théorique et probablement faux.<br />
<br />
<br />
Pour les masses, considérons ce qu'il faut comme longueur de tube par module:<br />
* Cabine: 20m de tube<br />
* Bras: 5m de tube<br />
* Structure: 12m de tube<br />
<br />
On peut du coup faire une estimation du poids de chacun des modules:<br />
* Masse tube Acier 50x50x3: 4,8kg/m (8000x50x4*3/1000000000)<br />
* Cabine: 250kg<br />
** 100kg tubes<br />
** 15kg siege<br />
** 100kg personne<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Bras:85kg<br />
** 50kg tubes (1m compte pour 2m, car tube plus gros)<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Structure: 275kg<br />
** 240kg tubes (1m compte pour 4m, car tube plus gros)<br />
** 15kg motorisation<br />
** 20kg materiel<br />
<br />
On obtient une masse totale pour la version tube acier d'environ 600kg<br />
<br />
On peut du coup s'essayer à des calculs et estimation de Résistance Des Matériaux. C'est vraiment pour le fun, parce que j'y connais rien ! Saint Wikipedia, priez pour moi !<br />
* http://fr.wikipedia.org/wiki/Th%C3%A9orie_des_poutres<br />
* http://fr.wikipedia.org/wiki/Fl%C3%A8che_%28r%C3%A9sistance_des_mat%C3%A9riaux%29<br />
* fleche = -FxL^3/(3EI) (unités ?)<br />
* http://fr.wikipedia.org/wiki/Module_d%27inertie<br />
** I_50x50x3 = (0.050^4-0.044^4)/12 = 2.08 10^-7 m^4<br />
** I_100x100x3 = (0.100^4-0.094^4)/12 = 1.83 10^-6 m^4<br />
** I_200x200x3 = (0.200^4-0.194^4)/12 = 1.53 10^-5 m^4<br />
* http://fr.wikipedia.org/wiki/Module_de_Young#Quelques_valeurs_num.C3.A9riques_de_modules_de_Young<br />
** E_Acier = 210 (GPa..? http://www.translatorscafe.com/cafe/EN/units-converter/pressure/5-20/gigapascal-newton%2Fmillimeter%C2%B2/ ?) => 2,1 x 10^11 N/m²<br />
<br />
Et c'est parti pour l'application numérique:<br />
* RDM de la nacelle:<br />
** 50x50x3mm de section, acier.<br />
** longerons: L=0.5m, 100/2kg (500N)<br />
** fleche = 0.47mm....? (d'après ma feuille de calcul excel)<br />
* RDM Bras:<br />
** jonction nacelle/bras: poutre extremité L=0.8m, masse statique 250/2kg (1200N)<br />
** similaire pour l'autre troncon de poutre (axe structure/bras vers angle bras).<br />
** 100x100x3mm de section, acier.<br />
** fleche = 0.53mm ...? (d'après ma feuille de calcul excel)<br />
* RDM structure:<br />
** L=0.5 (jusqu'à triangle de soutien), masse statique = 350kg (3500N)<br />
** 200x200x3mm de section, acier.<br />
** fleche = 0.05 mm...? (d'après ma feuille de calcul excel)<br />
<br />
Pour ce que valent ces quelques calculs, les sections 50x50x3 et 100x100x3 sont bien, la 200x200x3 est un peu overkill ;) En prenant les meme longueurs, mais avec du 100x100 on revient à une fleche de 0.38mm sur la structure... Peut être qu'il faut vérifier ces calculs et refaire avec des poutres en profilé alu (qu'on peut choisir avec une résistance similaire à ces poutres acier).<br />
<br />
===== Version poutres profilé alu =====<br />
A faire, en prenant des poutres à la résistance similaire aux versions acier, comme point de départ?<br />
* I_Acier_50x50_3 : 20.8 cm^4<br />
* I_Acier_100x100_3 : 183 cm^4<br />
* E_Acier: 210 Gpa<br />
* E_Alu: 69 Gpa<br />
Du coup, il faudrait (pour les même fleches et masses):<br />
* Alu remplacement du 50x50x3: 63.30 cm^4<br />
* Alu remplacement du 100x100x3: 557 cm^4<br />
<br />
<br />
Chez motedis, on trouve plein de choses:<br />
* Profile 40x40L I-Type slot 8 (section carrée 40x40mm)<br />
** masse: 1.74kg/m<br />
** moment x/y: 9 cm^4<br />
** 9 €/m<br />
** => clairement trop petit, sauf ptet pour des sous sections...<br />
<br />
* Profile (section rectangle 40x80mm) pas la spec!<br />
** masse: 3.04kg/m<br />
** moment 16 et 69cm^4<br />
** 16€/m<br />
** => Semble pas mal pour remplacement 50x50x3!<br />
<br />
* Profile 80x80<br />
** masse: 5.34kg/m<br />
** moment 135cm^4<br />
** 30€/m<br />
** => intermédiaire...<br />
<br />
<br />
* Profile 40x120L I-Type slot 8<br />
** masse: 4.35kg/m<br />
** moment 24 et 220cm^4<br />
** 25€/m<br />
** => intermédiaire...<br />
<br />
* Profile 40x160L I-Type slot 8 (section rectangle 40x160mm)<br />
** masse: 5.6kg/m<br />
** moment 30 et 500cm^4<br />
** 35€/m<br />
** => remplace le 100x100x3...<br />
<br />
===== Dimensionnement moteur =====<br />
RAPPEL: ce qui suit est hautement théorique et probablement faux.<br />
<br />
Il nous faut modéliser même grossièrement l'ensemble, et en particulier, trouver un moment d'inertie sur chaque axe pour pouvoir calculer l'accélération angulaire pour un couple moteur donné. Pas facile à modéliser quand on est noob, mais disons:<br />
* pour la nacelle, une boule de 250kg et 1m de diametre => 2/5 * 250 * 1 = 100 kg/m²<br />
* pour l'ensemble bras/nacelle, une boulle de 350 kg et 1.5m de diametre => 2/5 * 350 * 1.5² = 315 kg/m²<br />
Tout ceci est tout à fait arbitraire, mais dans l'idée, vu la répartition des masses, ce sera OK en première approche/pour un ordre de grandeur.<br />
<br />
Calculons maintenant le couple moteur requis sur chaque axe:<br />
* En regardant les servomoteurs industriels sur Aliexpress (aux alentours de 1kW), on voit qu'ils ont un couple nominal aux alentours de 5N.m à 3000rpm.<br />
* un réducteur 1:30 (qui passe le couple) donne presque 2 tours/seconde (quand même...), probablement qu'il faut au moins cette réduction, et donc le couple min sera de 150N.m (je néglige les pertes).<br />
* un réducteur 1:100 donne 2s pour faire un tour, encore respectable, et un couple de 500N.m (!)<br />
<br />
Petit retour à saint wikipedia pour calculer l'accélération angulaire, avec la formule J dw = M :<br />
* 100 kg/m² * dw rad/s² = 150 Nm => 1.5 rad/s² => 86 °/s², 8 secondes pour vmax<br />
* 315 kg/m² * dw rad/s² = 150 Nm => 0.48 rad/s² => 27 °/s², 25 secondes pour vmax<br />
* 100 kg/m² * dw rad/s² = 500 Nm => 5 rad/s² => 286 °/s², moins d'1 seconde pour vmax<br />
* 315 kg/m² * dw rad/s² = 500 Nm => 1.59 rad/s² => 91 °/s², 2 secondes pour vmax<br />
<br />
Probablement qu'une réduction plus proche de 100:1 est appropriée... ou bien un couple nominal encore plus important (eg 2kW sur l'axe bras?).<br />
Type de pièces:<br />
* SErvomotor 1kW: https://fr.aliexpress.com/item/1SET-AC-SERVO-MOTOR-DRIVER-SYSTEM-4N-M-1KW-2500RPM-90ST-AC-SERVO-MOTOR-90ST-M04025/32355566171.html?spm=2114.06010108.3.2.TqQNxi&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=7f665025-eb17-4db3-a67d-ab7f25b27590&algo_expid=0c727d85-513a-44f4-b2c8-695440ce9c04-0&algo_pvid=0c727d85-513a-44f4-b2c8-695440ce9c04<br />
* Reducteur (à vérifier la bride d'entrée!) https://fr.aliexpress.com/item/Bonfiglioli-Like-NMRV063-Worm-Wheel-Drive-Transmission-Gearbox-for-Ceramic-Industry/762259147.html?spm=2114.06010108.3.17.vyDUB4&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=ba79f59c-f6da-4075-a8a9-28b61a1a74ce&algo_expid=01b65d70-8ca2-42d3-927f-1acb226b6c58-1&algo_pvid=01b65d70-8ca2-42d3-927f-1acb226b6c58 => 7.5 à 100<br />
* Servo 2kW + Frein à manque de courant (peut être que frein c'est pas con...) https://fr.aliexpress.com/item/Delta-2KW-AC-Servo-Drive-and-Motor-ASD-A2-2023-L-ECMA-E11320SS-Brand-New-and/1108352617.html?spm=2114.06010108.3.2.sIa8NG&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=cb7b4097-596c-4793-beb9-7bfd3ac3f45a&algo_expid=b2521d12-9eca-46ee-b66d-5247b958fc22-0&algo_pvid=b2521d12-9eca-46ee-b66d-5247b958fc22<br />
* Note: moteurs 120w DC pour plateforme: https://fr.aliexpress.com/item/5D120GN-RV30-DC12V-24V-120W-1800rpm-DC-gear-motor-worm-gear-gearbox-high-torque-gear-motor/32754119224.html?spm=2114.06010108.3.85.EfcagF&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=9b90cc22-cbe4-4892-a639-5f1d0ab4da7d&algo_expid=9475ebd0-9b07-4cde-8c6f-4e73565279d0-11&algo_pvid=9475ebd0-9b07-4cde-8c6f-4e73565279d0</div>Clémenthttps://wiki.electrolab.fr/Projets:Perso:Siege_dynamiqueProjets:Perso:Siege dynamique2017-02-27T15:31:40Z<p>Clément: /* Version poutres profilé alu */</p>
<hr />
<div>'''Relance du projet par Limesle et Clem'''<br />
<br />
{{Project<br />
|name= Siège dynamique pour simulateur<br />
|author= [[User:Limesle|Limesle]]<br />
|proposal_date= 16/11/2012<br />
|abstract1=*Fabriquation d'un siège dynamique du type : [[http://www.racingfr.com/forum/index.php?showtopic=22814 Lien sur Racing.fr]]<br />
|abstract2=*Projet qui regroupe plusieurs compétences à développer : Electronique et mécanique<br />
|abstract3=*Projet qui peut fédérer d'autres membres par le plaisir<br />
|tags=dynamique, simulateur<br />
|where=à la maison<br />
|for_who= Ceux qui sont restés joueurs!<br />
|official_electrolab_project= no<br />
}}<br />
==Les buts poursuivis==<br />
#Produire un siège efficace dans sa dynamique (puissance vérins ou moteurs, réactivité etc ...)<br />
#Rester dans une enveloppe de prix raisonnable (à définir car très relatif tout ça)<br />
#Le projet doit être reproductible et donc bien documenté<br />
#La machine obtenue doit être suffisament sécure, pour le pilote comme pour les observateurs (Coupe circuit, cellule photo de franchissement ?)<br />
#Le résultat doit être adapté à différents jeux : simulation voiture et avion a minima, voire parapente et simulateur vol oiseau<br />
#Afin de permettre une bonne immersion, les périphériques et écrans devraient être solidaires du siège (ex : [[http://www.buzzmoica.fr/video/jeu-simulation-formule1-sur-verins-hydrauliques-11418 vidéo]])<br />
# autre solution : google cardboard ou Oculus Rift ou autre HTC Vive<br />
<br />
<br />
Les rubriques liées au développement seront :<br />
*La structure support<br />
*Les actionneurs<br />
*Les périphériques électroniques (Ordi et écran compris)<br />
*La carte de control<br />
*La programmation et les signaux et/ou informations émis par les jeux et à traduire en mouvement<br />
<br />
<br />
==Les informations de départ==<br />
Etat des lieux de la "science"<br />
Birdly de Somniacs [[https://www.youtube.com/watch?v=gWLHIusLWOc&t=77s]]<br />
Hypersuit de Theory [[https://www.youtube.com/watch?v=0WpB_nzeocM]]<br />
<br />
Cabine 360 [[https://www.youtube.com/watch?v=TokSLPB5_Bs]]<br />
[[https://www.xsimulator.net/community/threads/x-sim-360%C2%B0-2dof-motion-flight-pit-with-arduino-for-dcs-world.7224/]]<br />
<br />
Exemple d'écrans high tech : [[https://www.youtube.com/watch?v=xBE16eBJK6E&t=3s]]<br />
<br />
==L'électronique force feedback==<br />
Exemple 2DOS avec base simple et arduino :[[http://www.etr.fr/tutorial/1353-fabriquer-un-simulateur-pour-moins-de-450.html]]<br />
<br />
==Les softs de transfert info Jeu vers actionneurs==<br />
*[[https://www.xsimulator.net/]]<br />
*[[http://x-sim.de/forum/portal.php]]<br />
<br />
<br />
==Les actionneurs==<br />
<br />
===Vérins===<br />
Système par vérin double entrée pour avoir toutes les positions possibles.<br />
*[[Robotique:Equipement#Verrin|Les vérins pneumatiques en robotique]]<br />
*[[http://fr.wikipedia.org/wiki/V%C3%A9rin Vérins sur Wikipédia]]<br />
*[[http://www.festo.com/cms/fr_fr/index.htm FESTO]]<br />
<br />
Exemple à vérin pneumatiques<br />
<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques :<br />
<br />
===Moteurs Pas à Pas===<br />
<br />
===Gyroscopes===<br />
<br />
= Les différents types de machines =<br />
<br />
== Types de plateforme ==<br />
=== 2 DoF ===<br />
<br />
=== 3 DoF ===<br />
<br />
== Type rotations ==<br />
=== 2 DoF Joyrider ===<br />
<br />
=== 2 DoF 360° ===<br />
Exemple du R360 de SEGA, à 2 axes en révolution complète:<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques : [[http://www.gameroomrepair.com/R360/R360.htm]] et [[http://www.system16.com/hardware.php?id=844]]<br />
<br />
Exemple de copies chinoises:<br />
*{ref]<br />
*{ref]<br />
*{ref]<br />
<br />
<br />
A priori l'une des machines les plus compliquées à fabriquer, de par les contraintes... une bonne approche est probablement de fabriquer d'abord une maquette, comme [ref].<br />
<br />
<br />
==== Dimensionnement mécanique ====<br />
WARNING: je suis électronicien. Tout ce qui suit est probablement archi faux et rempli de conneries: merci de critiquer de manière constructive.<br />
<br />
<br />
Plusieurs approches sont envisageables pour la fabrication: tube acier carré soudé, profilé alu avec assemblage (peut être préférable). Afin de dimensionner de la mécanique/se faire une petite idée, voici un premier crobar très grossier:<br />
* [insert pic}<br />
<br />
Comme on le voit, le tout est constitué de trois modules:<br />
* une structure, liée au sol<br />
* un bras, entrainé en rotation<br />
* une cabine<br />
<br />
===== Version poutres acier =====<br />
RAPPEL: ce qui suit est hautement théorique et probablement faux.<br />
<br />
<br />
Pour les masses, considérons ce qu'il faut comme longueur de tube par module:<br />
* Cabine: 20m de tube<br />
* Bras: 5m de tube<br />
* Structure: 12m de tube<br />
<br />
On peut du coup faire une estimation du poids de chacun des modules:<br />
* Masse tube Acier 50x50x3: 4,8kg/m (8000x50x4*3/1000000000)<br />
* Cabine: 250kg<br />
** 100kg tubes<br />
** 15kg siege<br />
** 100kg personne<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Bras:85kg<br />
** 50kg tubes (1m compte pour 2m, car tube plus gros)<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Structure: 275kg<br />
** 240kg tubes (1m compte pour 4m, car tube plus gros)<br />
** 15kg motorisation<br />
** 20kg materiel<br />
<br />
On obtient une masse totale pour la version tube acier d'environ 600kg<br />
<br />
On peut du coup s'essayer à des calculs et estimation de Résistance Des Matériaux. C'est vraiment pour le fun, parce que j'y connais rien ! Saint Wikipedia, priez pour moi !<br />
* http://fr.wikipedia.org/wiki/Th%C3%A9orie_des_poutres<br />
* http://fr.wikipedia.org/wiki/Fl%C3%A8che_%28r%C3%A9sistance_des_mat%C3%A9riaux%29<br />
* fleche = -FxL^3/(3EI) (unités ?)<br />
* http://fr.wikipedia.org/wiki/Module_d%27inertie<br />
** I_50x50x3 = (0.050^4-0.044^4)/12 = 2.08 10^-7 m^4<br />
** I_100x100x3 = (0.100^4-0.094^4)/12 = 1.83 10^-6 m^4<br />
** I_200x200x3 = (0.200^4-0.194^4)/12 = 1.53 10^-5 m^4<br />
* http://fr.wikipedia.org/wiki/Module_de_Young#Quelques_valeurs_num.C3.A9riques_de_modules_de_Young<br />
** E_Acier = 210 (GPa..? http://www.translatorscafe.com/cafe/EN/units-converter/pressure/5-20/gigapascal-newton%2Fmillimeter%C2%B2/ ?) => 2,1 x 10^11 N/m²<br />
<br />
Et c'est parti pour l'application numérique:<br />
* RDM de la nacelle:<br />
** 50x50x3mm de section, acier.<br />
** longerons: L=0.5m, 100/2kg (500N)<br />
** fleche = 0.47mm....? (d'après ma feuille de calcul excel)<br />
* RDM Bras:<br />
** jonction nacelle/bras: poutre extremité L=0.8m, masse statique 250/2kg (1200N)<br />
** similaire pour l'autre troncon de poutre (axe structure/bras vers angle bras).<br />
** 100x100x3mm de section, acier.<br />
** fleche = 0.53mm ...? (d'après ma feuille de calcul excel)<br />
* RDM structure:<br />
** L=0.5 (jusqu'à triangle de soutien), masse statique = 350kg (3500N)<br />
** 200x200x3mm de section, acier.<br />
** fleche = 0.05 mm...? (d'après ma feuille de calcul excel)<br />
<br />
Pour ce que valent ces quelques calculs, les sections 50x50x3 et 100x100x3 sont bien, la 200x200x3 est un peu overkill ;) En prenant les meme longueurs, mais avec du 100x100 on revient à une fleche de 0.38mm sur la structure... Peut être qu'il faut vérifier ces calculs et refaire avec des poutres en profilé alu (qu'on peut choisir avec une résistance similaire à ces poutres acier).<br />
<br />
===== Version poutres profilé alu =====<br />
A faire, en prenant des poutres à la résistance similaire aux versions acier, comme point de départ?<br />
* I_Acier_50x50_3 : 20.8 cm^4<br />
* I_Acier_100x100_3 : 183 cm^4<br />
* E_Acier: 210 Gpa<br />
* E_Alu: 69 Gpa<br />
Du coup, il faudrait (pour les même fleches et masses):<br />
* Alu remplacement du 50x50x3: 63.30 cm^4<br />
* Alu remplacement du 100x100x3: 557 cm^4<br />
<br />
<br />
Chez motedis, on trouve plein de choses:<br />
* Profile 40x40L I-Type slot 8 (section carrée 40x40mm)<br />
** masse: 1.74kg/m<br />
** moment x/y: 9 cm^4<br />
** 9 €/m<br />
** => clairement trop petit, sauf ptet pour des sous sections...<br />
<br />
* Profile (section rectangle 40x80mm) pas la spec!<br />
** masse: ???kg/m<br />
** moment ???cm^4<br />
** 20€/m<br />
** => manque infos sur leur site<br />
<br />
* Profile 80x80<br />
** masse: 5.34kg/m<br />
** moment 135cm^4<br />
** 30€/m<br />
** => intermédiaire...<br />
<br />
<br />
* Profile 40x120L I-Type slot 8<br />
** masse: 4.35kg/m<br />
** moment 24 et 220cm^4<br />
** 25€/m<br />
** => intermédiaire...<br />
<br />
* Profile 40x160L I-Type slot 8 (section rectangle 40x160mm)<br />
** masse: 5.6kg/m<br />
** moment 30 et 500cm^4<br />
** 35€/m<br />
** => remplace le 100x100x3...<br />
<br />
===== Dimensionnement moteur =====<br />
RAPPEL: ce qui suit est hautement théorique et probablement faux.<br />
<br />
Il nous faut modéliser même grossièrement l'ensemble, et en particulier, trouver un moment d'inertie sur chaque axe pour pouvoir calculer l'accélération angulaire pour un couple moteur donné. Pas facile à modéliser quand on est noob, mais disons:<br />
* pour la nacelle, une boule de 250kg et 1m de diametre => 2/5 * 250 * 1 = 100 kg/m²<br />
* pour l'ensemble bras/nacelle, une boulle de 350 kg et 1.5m de diametre => 2/5 * 350 * 1.5² = 315 kg/m²<br />
Tout ceci est tout à fait arbitraire, mais dans l'idée, vu la répartition des masses, ce sera OK en première approche/pour un ordre de grandeur.<br />
<br />
Calculons maintenant le couple moteur requis sur chaque axe:<br />
* En regardant les servomoteurs industriels sur Aliexpress (aux alentours de 1kW), on voit qu'ils ont un couple nominal aux alentours de 5N.m à 3000rpm.<br />
* un réducteur 1:30 (qui passe le couple) donne presque 2 tours/seconde (quand même...), probablement qu'il faut au moins cette réduction, et donc le couple min sera de 150N.m (je néglige les pertes).<br />
* un réducteur 1:100 donne 2s pour faire un tour, encore respectable, et un couple de 500N.m (!)<br />
<br />
Petit retour à saint wikipedia pour calculer l'accélération angulaire, avec la formule J dw = M :<br />
* 100 kg/m² * dw rad/s² = 150 Nm => 1.5 rad/s² => 86 °/s², 8 secondes pour vmax<br />
* 315 kg/m² * dw rad/s² = 150 Nm => 0.48 rad/s² => 27 °/s², 25 secondes pour vmax<br />
* 100 kg/m² * dw rad/s² = 500 Nm => 5 rad/s² => 286 °/s², moins d'1 seconde pour vmax<br />
* 315 kg/m² * dw rad/s² = 500 Nm => 1.59 rad/s² => 91 °/s², 2 secondes pour vmax<br />
<br />
Probablement qu'une réduction plus proche de 100:1 est appropriée... ou bien un couple nominal encore plus important (eg 2kW sur l'axe bras?).<br />
Type de pièces:<br />
* SErvomotor 1kW: https://fr.aliexpress.com/item/1SET-AC-SERVO-MOTOR-DRIVER-SYSTEM-4N-M-1KW-2500RPM-90ST-AC-SERVO-MOTOR-90ST-M04025/32355566171.html?spm=2114.06010108.3.2.TqQNxi&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=7f665025-eb17-4db3-a67d-ab7f25b27590&algo_expid=0c727d85-513a-44f4-b2c8-695440ce9c04-0&algo_pvid=0c727d85-513a-44f4-b2c8-695440ce9c04<br />
* Reducteur (à vérifier la bride d'entrée!) https://fr.aliexpress.com/item/Bonfiglioli-Like-NMRV063-Worm-Wheel-Drive-Transmission-Gearbox-for-Ceramic-Industry/762259147.html?spm=2114.06010108.3.17.vyDUB4&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=ba79f59c-f6da-4075-a8a9-28b61a1a74ce&algo_expid=01b65d70-8ca2-42d3-927f-1acb226b6c58-1&algo_pvid=01b65d70-8ca2-42d3-927f-1acb226b6c58 => 7.5 à 100<br />
* Servo 2kW + Frein à manque de courant (peut être que frein c'est pas con...) https://fr.aliexpress.com/item/Delta-2KW-AC-Servo-Drive-and-Motor-ASD-A2-2023-L-ECMA-E11320SS-Brand-New-and/1108352617.html?spm=2114.06010108.3.2.sIa8NG&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=cb7b4097-596c-4793-beb9-7bfd3ac3f45a&algo_expid=b2521d12-9eca-46ee-b66d-5247b958fc22-0&algo_pvid=b2521d12-9eca-46ee-b66d-5247b958fc22<br />
* Note: moteurs 120w DC pour plateforme: https://fr.aliexpress.com/item/5D120GN-RV30-DC12V-24V-120W-1800rpm-DC-gear-motor-worm-gear-gearbox-high-torque-gear-motor/32754119224.html?spm=2114.06010108.3.85.EfcagF&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=9b90cc22-cbe4-4892-a639-5f1d0ab4da7d&algo_expid=9475ebd0-9b07-4cde-8c6f-4e73565279d0-11&algo_pvid=9475ebd0-9b07-4cde-8c6f-4e73565279d0</div>Clémenthttps://wiki.electrolab.fr/Projets:Perso:Siege_dynamiqueProjets:Perso:Siege dynamique2017-02-27T14:59:34Z<p>Clément: /* Version poutres profilé alu */</p>
<hr />
<div>'''Relance du projet par Limesle et Clem'''<br />
<br />
{{Project<br />
|name= Siège dynamique pour simulateur<br />
|author= [[User:Limesle|Limesle]]<br />
|proposal_date= 16/11/2012<br />
|abstract1=*Fabriquation d'un siège dynamique du type : [[http://www.racingfr.com/forum/index.php?showtopic=22814 Lien sur Racing.fr]]<br />
|abstract2=*Projet qui regroupe plusieurs compétences à développer : Electronique et mécanique<br />
|abstract3=*Projet qui peut fédérer d'autres membres par le plaisir<br />
|tags=dynamique, simulateur<br />
|where=à la maison<br />
|for_who= Ceux qui sont restés joueurs!<br />
|official_electrolab_project= no<br />
}}<br />
==Les buts poursuivis==<br />
#Produire un siège efficace dans sa dynamique (puissance vérins ou moteurs, réactivité etc ...)<br />
#Rester dans une enveloppe de prix raisonnable (à définir car très relatif tout ça)<br />
#Le projet doit être reproductible et donc bien documenté<br />
#La machine obtenue doit être suffisament sécure, pour le pilote comme pour les observateurs (Coupe circuit, cellule photo de franchissement ?)<br />
#Le résultat doit être adapté à différents jeux : simulation voiture et avion a minima, voire parapente et simulateur vol oiseau<br />
#Afin de permettre une bonne immersion, les périphériques et écrans devraient être solidaires du siège (ex : [[http://www.buzzmoica.fr/video/jeu-simulation-formule1-sur-verins-hydrauliques-11418 vidéo]])<br />
# autre solution : google cardboard ou Oculus Rift ou autre HTC Vive<br />
<br />
<br />
Les rubriques liées au développement seront :<br />
*La structure support<br />
*Les actionneurs<br />
*Les périphériques électroniques (Ordi et écran compris)<br />
*La carte de control<br />
*La programmation et les signaux et/ou informations émis par les jeux et à traduire en mouvement<br />
<br />
<br />
==Les informations de départ==<br />
Etat des lieux de la "science"<br />
Birdly de Somniacs [[https://www.youtube.com/watch?v=gWLHIusLWOc&t=77s]]<br />
Hypersuit de Theory [[https://www.youtube.com/watch?v=0WpB_nzeocM]]<br />
<br />
Cabine 360 [[https://www.youtube.com/watch?v=TokSLPB5_Bs]]<br />
[[https://www.xsimulator.net/community/threads/x-sim-360%C2%B0-2dof-motion-flight-pit-with-arduino-for-dcs-world.7224/]]<br />
<br />
Exemple d'écrans high tech : [[https://www.youtube.com/watch?v=xBE16eBJK6E&t=3s]]<br />
<br />
==L'électronique force feedback==<br />
Exemple 2DOS avec base simple et arduino :[[http://www.etr.fr/tutorial/1353-fabriquer-un-simulateur-pour-moins-de-450.html]]<br />
<br />
==Les softs de transfert info Jeu vers actionneurs==<br />
*[[https://www.xsimulator.net/]]<br />
*[[http://x-sim.de/forum/portal.php]]<br />
<br />
<br />
==Les actionneurs==<br />
<br />
===Vérins===<br />
Système par vérin double entrée pour avoir toutes les positions possibles.<br />
*[[Robotique:Equipement#Verrin|Les vérins pneumatiques en robotique]]<br />
*[[http://fr.wikipedia.org/wiki/V%C3%A9rin Vérins sur Wikipédia]]<br />
*[[http://www.festo.com/cms/fr_fr/index.htm FESTO]]<br />
<br />
Exemple à vérin pneumatiques<br />
<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques :<br />
<br />
===Moteurs Pas à Pas===<br />
<br />
===Gyroscopes===<br />
<br />
= Les différents types de machines =<br />
<br />
== Types de plateforme ==<br />
=== 2 DoF ===<br />
<br />
=== 3 DoF ===<br />
<br />
== Type rotations ==<br />
=== 2 DoF Joyrider ===<br />
<br />
=== 2 DoF 360° ===<br />
Exemple du R360 de SEGA, à 2 axes en révolution complète:<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques : [[http://www.gameroomrepair.com/R360/R360.htm]] et [[http://www.system16.com/hardware.php?id=844]]<br />
<br />
Exemple de copies chinoises:<br />
*{ref]<br />
*{ref]<br />
*{ref]<br />
<br />
<br />
A priori l'une des machines les plus compliquées à fabriquer, de par les contraintes... une bonne approche est probablement de fabriquer d'abord une maquette, comme [ref].<br />
<br />
<br />
==== Dimensionnement mécanique ====<br />
WARNING: je suis électronicien. Tout ce qui suit est probablement archi faux et rempli de conneries: merci de critiquer de manière constructive.<br />
<br />
<br />
Plusieurs approches sont envisageables pour la fabrication: tube acier carré soudé, profilé alu avec assemblage (peut être préférable). Afin de dimensionner de la mécanique/se faire une petite idée, voici un premier crobar très grossier:<br />
* [insert pic}<br />
<br />
Comme on le voit, le tout est constitué de trois modules:<br />
* une structure, liée au sol<br />
* un bras, entrainé en rotation<br />
* une cabine<br />
<br />
===== Version poutres acier =====<br />
RAPPEL: ce qui suit est hautement théorique et probablement faux.<br />
<br />
<br />
Pour les masses, considérons ce qu'il faut comme longueur de tube par module:<br />
* Cabine: 20m de tube<br />
* Bras: 5m de tube<br />
* Structure: 12m de tube<br />
<br />
On peut du coup faire une estimation du poids de chacun des modules:<br />
* Masse tube Acier 50x50x3: 4,8kg/m (8000x50x4*3/1000000000)<br />
* Cabine: 250kg<br />
** 100kg tubes<br />
** 15kg siege<br />
** 100kg personne<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Bras:85kg<br />
** 50kg tubes (1m compte pour 2m, car tube plus gros)<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Structure: 275kg<br />
** 240kg tubes (1m compte pour 4m, car tube plus gros)<br />
** 15kg motorisation<br />
** 20kg materiel<br />
<br />
On obtient une masse totale pour la version tube acier d'environ 600kg<br />
<br />
On peut du coup s'essayer à des calculs et estimation de Résistance Des Matériaux. C'est vraiment pour le fun, parce que j'y connais rien ! Saint Wikipedia, priez pour moi !<br />
* http://fr.wikipedia.org/wiki/Th%C3%A9orie_des_poutres<br />
* http://fr.wikipedia.org/wiki/Fl%C3%A8che_%28r%C3%A9sistance_des_mat%C3%A9riaux%29<br />
* fleche = -FxL^3/(3EI) (unités ?)<br />
* http://fr.wikipedia.org/wiki/Module_d%27inertie<br />
** I_50x50x3 = (0.050^4-0.044^4)/12 = 2.08 10^-7 m^4<br />
** I_100x100x3 = (0.100^4-0.094^4)/12 = 1.83 10^-6 m^4<br />
** I_200x200x3 = (0.200^4-0.194^4)/12 = 1.53 10^-5 m^4<br />
* http://fr.wikipedia.org/wiki/Module_de_Young#Quelques_valeurs_num.C3.A9riques_de_modules_de_Young<br />
** E_Acier = 210 (GPa..? http://www.translatorscafe.com/cafe/EN/units-converter/pressure/5-20/gigapascal-newton%2Fmillimeter%C2%B2/ ?) => 2,1 x 10^11 N/m²<br />
<br />
Et c'est parti pour l'application numérique:<br />
* RDM de la nacelle:<br />
** 50x50x3mm de section, acier.<br />
** longerons: L=0.5m, 100/2kg (500N)<br />
** fleche = 0.47mm....? (d'après ma feuille de calcul excel)<br />
* RDM Bras:<br />
** jonction nacelle/bras: poutre extremité L=0.8m, masse statique 250/2kg (1200N)<br />
** similaire pour l'autre troncon de poutre (axe structure/bras vers angle bras).<br />
** 100x100x3mm de section, acier.<br />
** fleche = 0.53mm ...? (d'après ma feuille de calcul excel)<br />
* RDM structure:<br />
** L=0.5 (jusqu'à triangle de soutien), masse statique = 350kg (3500N)<br />
** 200x200x3mm de section, acier.<br />
** fleche = 0.05 mm...? (d'après ma feuille de calcul excel)<br />
<br />
Pour ce que valent ces quelques calculs, les sections 50x50x3 et 100x100x3 sont bien, la 200x200x3 est un peu overkill ;) En prenant les meme longueurs, mais avec du 100x100 on revient à une fleche de 0.38mm sur la structure... Peut être qu'il faut vérifier ces calculs et refaire avec des poutres en profilé alu (qu'on peut choisir avec une résistance similaire à ces poutres acier).<br />
<br />
===== Version poutres profilé alu =====<br />
A faire, en prenant des poutres à la résistance similaire aux versions acier, comme point de départ?<br />
<br />
Chez motedis, on trouve:<br />
* Profile 40x40L I-Type slot 8,<br />
** masse: 1.74kg/m<br />
** moment x/y: 9 cm^4<br />
<br />
===== Dimensionnement moteur =====<br />
RAPPEL: ce qui suit est hautement théorique et probablement faux.<br />
<br />
Il nous faut modéliser même grossièrement l'ensemble, et en particulier, trouver un moment d'inertie sur chaque axe pour pouvoir calculer l'accélération angulaire pour un couple moteur donné. Pas facile à modéliser quand on est noob, mais disons:<br />
* pour la nacelle, une boule de 250kg et 1m de diametre => 2/5 * 250 * 1 = 100 kg/m²<br />
* pour l'ensemble bras/nacelle, une boulle de 350 kg et 1.5m de diametre => 2/5 * 350 * 1.5² = 315 kg/m²<br />
Tout ceci est tout à fait arbitraire, mais dans l'idée, vu la répartition des masses, ce sera OK en première approche/pour un ordre de grandeur.<br />
<br />
Calculons maintenant le couple moteur requis sur chaque axe:<br />
* En regardant les servomoteurs industriels sur Aliexpress (aux alentours de 1kW), on voit qu'ils ont un couple nominal aux alentours de 5N.m à 3000rpm.<br />
* un réducteur 1:30 (qui passe le couple) donne presque 2 tours/seconde (quand même...), probablement qu'il faut au moins cette réduction, et donc le couple min sera de 150N.m (je néglige les pertes).<br />
* un réducteur 1:100 donne 2s pour faire un tour, encore respectable, et un couple de 500N.m (!)<br />
<br />
Petit retour à saint wikipedia pour calculer l'accélération angulaire, avec la formule J dw = M :<br />
* 100 kg/m² * dw rad/s² = 150 Nm => 1.5 rad/s² => 86 °/s², 8 secondes pour vmax<br />
* 315 kg/m² * dw rad/s² = 150 Nm => 0.48 rad/s² => 27 °/s², 25 secondes pour vmax<br />
* 100 kg/m² * dw rad/s² = 500 Nm => 5 rad/s² => 286 °/s², moins d'1 seconde pour vmax<br />
* 315 kg/m² * dw rad/s² = 500 Nm => 1.59 rad/s² => 91 °/s², 2 secondes pour vmax<br />
<br />
Probablement qu'une réduction plus proche de 100:1 est appropriée... ou bien un couple nominal encore plus important (eg 2kW sur l'axe bras?).<br />
Type de pièces:<br />
* SErvomotor 1kW: https://fr.aliexpress.com/item/1SET-AC-SERVO-MOTOR-DRIVER-SYSTEM-4N-M-1KW-2500RPM-90ST-AC-SERVO-MOTOR-90ST-M04025/32355566171.html?spm=2114.06010108.3.2.TqQNxi&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=7f665025-eb17-4db3-a67d-ab7f25b27590&algo_expid=0c727d85-513a-44f4-b2c8-695440ce9c04-0&algo_pvid=0c727d85-513a-44f4-b2c8-695440ce9c04<br />
* Reducteur (à vérifier la bride d'entrée!) https://fr.aliexpress.com/item/Bonfiglioli-Like-NMRV063-Worm-Wheel-Drive-Transmission-Gearbox-for-Ceramic-Industry/762259147.html?spm=2114.06010108.3.17.vyDUB4&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=ba79f59c-f6da-4075-a8a9-28b61a1a74ce&algo_expid=01b65d70-8ca2-42d3-927f-1acb226b6c58-1&algo_pvid=01b65d70-8ca2-42d3-927f-1acb226b6c58 => 7.5 à 100<br />
* Servo 2kW + Frein à manque de courant (peut être que frein c'est pas con...) https://fr.aliexpress.com/item/Delta-2KW-AC-Servo-Drive-and-Motor-ASD-A2-2023-L-ECMA-E11320SS-Brand-New-and/1108352617.html?spm=2114.06010108.3.2.sIa8NG&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=cb7b4097-596c-4793-beb9-7bfd3ac3f45a&algo_expid=b2521d12-9eca-46ee-b66d-5247b958fc22-0&algo_pvid=b2521d12-9eca-46ee-b66d-5247b958fc22<br />
* Note: moteurs 120w DC pour plateforme: https://fr.aliexpress.com/item/5D120GN-RV30-DC12V-24V-120W-1800rpm-DC-gear-motor-worm-gear-gearbox-high-torque-gear-motor/32754119224.html?spm=2114.06010108.3.85.EfcagF&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=9b90cc22-cbe4-4892-a639-5f1d0ab4da7d&algo_expid=9475ebd0-9b07-4cde-8c6f-4e73565279d0-11&algo_pvid=9475ebd0-9b07-4cde-8c6f-4e73565279d0</div>Clémenthttps://wiki.electrolab.fr/Projets:Perso:Siege_dynamiqueProjets:Perso:Siege dynamique2017-02-27T14:54:17Z<p>Clément: /* 2 DoF 360° */</p>
<hr />
<div>'''Relance du projet par Limesle et Clem'''<br />
<br />
{{Project<br />
|name= Siège dynamique pour simulateur<br />
|author= [[User:Limesle|Limesle]]<br />
|proposal_date= 16/11/2012<br />
|abstract1=*Fabriquation d'un siège dynamique du type : [[http://www.racingfr.com/forum/index.php?showtopic=22814 Lien sur Racing.fr]]<br />
|abstract2=*Projet qui regroupe plusieurs compétences à développer : Electronique et mécanique<br />
|abstract3=*Projet qui peut fédérer d'autres membres par le plaisir<br />
|tags=dynamique, simulateur<br />
|where=à la maison<br />
|for_who= Ceux qui sont restés joueurs!<br />
|official_electrolab_project= no<br />
}}<br />
==Les buts poursuivis==<br />
#Produire un siège efficace dans sa dynamique (puissance vérins ou moteurs, réactivité etc ...)<br />
#Rester dans une enveloppe de prix raisonnable (à définir car très relatif tout ça)<br />
#Le projet doit être reproductible et donc bien documenté<br />
#La machine obtenue doit être suffisament sécure, pour le pilote comme pour les observateurs (Coupe circuit, cellule photo de franchissement ?)<br />
#Le résultat doit être adapté à différents jeux : simulation voiture et avion a minima, voire parapente et simulateur vol oiseau<br />
#Afin de permettre une bonne immersion, les périphériques et écrans devraient être solidaires du siège (ex : [[http://www.buzzmoica.fr/video/jeu-simulation-formule1-sur-verins-hydrauliques-11418 vidéo]])<br />
# autre solution : google cardboard ou Oculus Rift ou autre HTC Vive<br />
<br />
<br />
Les rubriques liées au développement seront :<br />
*La structure support<br />
*Les actionneurs<br />
*Les périphériques électroniques (Ordi et écran compris)<br />
*La carte de control<br />
*La programmation et les signaux et/ou informations émis par les jeux et à traduire en mouvement<br />
<br />
<br />
==Les informations de départ==<br />
Etat des lieux de la "science"<br />
Birdly de Somniacs [[https://www.youtube.com/watch?v=gWLHIusLWOc&t=77s]]<br />
Hypersuit de Theory [[https://www.youtube.com/watch?v=0WpB_nzeocM]]<br />
<br />
Cabine 360 [[https://www.youtube.com/watch?v=TokSLPB5_Bs]]<br />
[[https://www.xsimulator.net/community/threads/x-sim-360%C2%B0-2dof-motion-flight-pit-with-arduino-for-dcs-world.7224/]]<br />
<br />
Exemple d'écrans high tech : [[https://www.youtube.com/watch?v=xBE16eBJK6E&t=3s]]<br />
<br />
==L'électronique force feedback==<br />
Exemple 2DOS avec base simple et arduino :[[http://www.etr.fr/tutorial/1353-fabriquer-un-simulateur-pour-moins-de-450.html]]<br />
<br />
==Les softs de transfert info Jeu vers actionneurs==<br />
*[[https://www.xsimulator.net/]]<br />
*[[http://x-sim.de/forum/portal.php]]<br />
<br />
<br />
==Les actionneurs==<br />
<br />
===Vérins===<br />
Système par vérin double entrée pour avoir toutes les positions possibles.<br />
*[[Robotique:Equipement#Verrin|Les vérins pneumatiques en robotique]]<br />
*[[http://fr.wikipedia.org/wiki/V%C3%A9rin Vérins sur Wikipédia]]<br />
*[[http://www.festo.com/cms/fr_fr/index.htm FESTO]]<br />
<br />
Exemple à vérin pneumatiques<br />
<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques :<br />
<br />
===Moteurs Pas à Pas===<br />
<br />
===Gyroscopes===<br />
<br />
= Les différents types de machines =<br />
<br />
== Types de plateforme ==<br />
=== 2 DoF ===<br />
<br />
=== 3 DoF ===<br />
<br />
== Type rotations ==<br />
=== 2 DoF Joyrider ===<br />
<br />
=== 2 DoF 360° ===<br />
Exemple du R360 de SEGA, à 2 axes en révolution complète:<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques : [[http://www.gameroomrepair.com/R360/R360.htm]] et [[http://www.system16.com/hardware.php?id=844]]<br />
<br />
Exemple de copies chinoises:<br />
*{ref]<br />
*{ref]<br />
*{ref]<br />
<br />
<br />
A priori l'une des machines les plus compliquées à fabriquer, de par les contraintes... une bonne approche est probablement de fabriquer d'abord une maquette, comme [ref].<br />
<br />
<br />
==== Dimensionnement mécanique ====<br />
WARNING: je suis électronicien. Tout ce qui suit est probablement archi faux et rempli de conneries: merci de critiquer de manière constructive.<br />
<br />
<br />
Plusieurs approches sont envisageables pour la fabrication: tube acier carré soudé, profilé alu avec assemblage (peut être préférable). Afin de dimensionner de la mécanique/se faire une petite idée, voici un premier crobar très grossier:<br />
* [insert pic}<br />
<br />
Comme on le voit, le tout est constitué de trois modules:<br />
* une structure, liée au sol<br />
* un bras, entrainé en rotation<br />
* une cabine<br />
<br />
===== Version poutres acier =====<br />
RAPPEL: ce qui suit est hautement théorique et probablement faux.<br />
<br />
<br />
Pour les masses, considérons ce qu'il faut comme longueur de tube par module:<br />
* Cabine: 20m de tube<br />
* Bras: 5m de tube<br />
* Structure: 12m de tube<br />
<br />
On peut du coup faire une estimation du poids de chacun des modules:<br />
* Masse tube Acier 50x50x3: 4,8kg/m (8000x50x4*3/1000000000)<br />
* Cabine: 250kg<br />
** 100kg tubes<br />
** 15kg siege<br />
** 100kg personne<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Bras:85kg<br />
** 50kg tubes (1m compte pour 2m, car tube plus gros)<br />
** 15kg motorisation<br />
** 20kg matériel<br />
* Structure: 275kg<br />
** 240kg tubes (1m compte pour 4m, car tube plus gros)<br />
** 15kg motorisation<br />
** 20kg materiel<br />
<br />
On obtient une masse totale pour la version tube acier d'environ 600kg<br />
<br />
On peut du coup s'essayer à des calculs et estimation de Résistance Des Matériaux. C'est vraiment pour le fun, parce que j'y connais rien ! Saint Wikipedia, priez pour moi !<br />
* http://fr.wikipedia.org/wiki/Th%C3%A9orie_des_poutres<br />
* http://fr.wikipedia.org/wiki/Fl%C3%A8che_%28r%C3%A9sistance_des_mat%C3%A9riaux%29<br />
* fleche = -FxL^3/(3EI) (unités ?)<br />
* http://fr.wikipedia.org/wiki/Module_d%27inertie<br />
** I_50x50x3 = (0.050^4-0.044^4)/12 = 2.08 10^-7 m^4<br />
** I_100x100x3 = (0.100^4-0.094^4)/12 = 1.83 10^-6 m^4<br />
** I_200x200x3 = (0.200^4-0.194^4)/12 = 1.53 10^-5 m^4<br />
* http://fr.wikipedia.org/wiki/Module_de_Young#Quelques_valeurs_num.C3.A9riques_de_modules_de_Young<br />
** E_Acier = 210 (GPa..? http://www.translatorscafe.com/cafe/EN/units-converter/pressure/5-20/gigapascal-newton%2Fmillimeter%C2%B2/ ?) => 2,1 x 10^11 N/m²<br />
<br />
Et c'est parti pour l'application numérique:<br />
* RDM de la nacelle:<br />
** 50x50x3mm de section, acier.<br />
** longerons: L=0.5m, 100/2kg (500N)<br />
** fleche = 0.47mm....? (d'après ma feuille de calcul excel)<br />
* RDM Bras:<br />
** jonction nacelle/bras: poutre extremité L=0.8m, masse statique 250/2kg (1200N)<br />
** similaire pour l'autre troncon de poutre (axe structure/bras vers angle bras).<br />
** 100x100x3mm de section, acier.<br />
** fleche = 0.53mm ...? (d'après ma feuille de calcul excel)<br />
* RDM structure:<br />
** L=0.5 (jusqu'à triangle de soutien), masse statique = 350kg (3500N)<br />
** 200x200x3mm de section, acier.<br />
** fleche = 0.05 mm...? (d'après ma feuille de calcul excel)<br />
<br />
Pour ce que valent ces quelques calculs, les sections 50x50x3 et 100x100x3 sont bien, la 200x200x3 est un peu overkill ;) En prenant les meme longueurs, mais avec du 100x100 on revient à une fleche de 0.38mm sur la structure... Peut être qu'il faut vérifier ces calculs et refaire avec des poutres en profilé alu (qu'on peut choisir avec une résistance similaire à ces poutres acier).<br />
<br />
===== Version poutres profilé alu =====<br />
A faire, en prenant des poutres à la résistance similaire aux versions acier, comme point de départ?<br />
<br />
===== Dimensionnement moteur =====<br />
RAPPEL: ce qui suit est hautement théorique et probablement faux.<br />
<br />
Il nous faut modéliser même grossièrement l'ensemble, et en particulier, trouver un moment d'inertie sur chaque axe pour pouvoir calculer l'accélération angulaire pour un couple moteur donné. Pas facile à modéliser quand on est noob, mais disons:<br />
* pour la nacelle, une boule de 250kg et 1m de diametre => 2/5 * 250 * 1 = 100 kg/m²<br />
* pour l'ensemble bras/nacelle, une boulle de 350 kg et 1.5m de diametre => 2/5 * 350 * 1.5² = 315 kg/m²<br />
Tout ceci est tout à fait arbitraire, mais dans l'idée, vu la répartition des masses, ce sera OK en première approche/pour un ordre de grandeur.<br />
<br />
Calculons maintenant le couple moteur requis sur chaque axe:<br />
* En regardant les servomoteurs industriels sur Aliexpress (aux alentours de 1kW), on voit qu'ils ont un couple nominal aux alentours de 5N.m à 3000rpm.<br />
* un réducteur 1:30 (qui passe le couple) donne presque 2 tours/seconde (quand même...), probablement qu'il faut au moins cette réduction, et donc le couple min sera de 150N.m (je néglige les pertes).<br />
* un réducteur 1:100 donne 2s pour faire un tour, encore respectable, et un couple de 500N.m (!)<br />
<br />
Petit retour à saint wikipedia pour calculer l'accélération angulaire, avec la formule J dw = M :<br />
* 100 kg/m² * dw rad/s² = 150 Nm => 1.5 rad/s² => 86 °/s², 8 secondes pour vmax<br />
* 315 kg/m² * dw rad/s² = 150 Nm => 0.48 rad/s² => 27 °/s², 25 secondes pour vmax<br />
* 100 kg/m² * dw rad/s² = 500 Nm => 5 rad/s² => 286 °/s², moins d'1 seconde pour vmax<br />
* 315 kg/m² * dw rad/s² = 500 Nm => 1.59 rad/s² => 91 °/s², 2 secondes pour vmax<br />
<br />
Probablement qu'une réduction plus proche de 100:1 est appropriée... ou bien un couple nominal encore plus important (eg 2kW sur l'axe bras?).<br />
Type de pièces:<br />
* SErvomotor 1kW: https://fr.aliexpress.com/item/1SET-AC-SERVO-MOTOR-DRIVER-SYSTEM-4N-M-1KW-2500RPM-90ST-AC-SERVO-MOTOR-90ST-M04025/32355566171.html?spm=2114.06010108.3.2.TqQNxi&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=7f665025-eb17-4db3-a67d-ab7f25b27590&algo_expid=0c727d85-513a-44f4-b2c8-695440ce9c04-0&algo_pvid=0c727d85-513a-44f4-b2c8-695440ce9c04<br />
* Reducteur (à vérifier la bride d'entrée!) https://fr.aliexpress.com/item/Bonfiglioli-Like-NMRV063-Worm-Wheel-Drive-Transmission-Gearbox-for-Ceramic-Industry/762259147.html?spm=2114.06010108.3.17.vyDUB4&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=ba79f59c-f6da-4075-a8a9-28b61a1a74ce&algo_expid=01b65d70-8ca2-42d3-927f-1acb226b6c58-1&algo_pvid=01b65d70-8ca2-42d3-927f-1acb226b6c58 => 7.5 à 100<br />
* Servo 2kW + Frein à manque de courant (peut être que frein c'est pas con...) https://fr.aliexpress.com/item/Delta-2KW-AC-Servo-Drive-and-Motor-ASD-A2-2023-L-ECMA-E11320SS-Brand-New-and/1108352617.html?spm=2114.06010108.3.2.sIa8NG&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=cb7b4097-596c-4793-beb9-7bfd3ac3f45a&algo_expid=b2521d12-9eca-46ee-b66d-5247b958fc22-0&algo_pvid=b2521d12-9eca-46ee-b66d-5247b958fc22<br />
* Note: moteurs 120w DC pour plateforme: https://fr.aliexpress.com/item/5D120GN-RV30-DC12V-24V-120W-1800rpm-DC-gear-motor-worm-gear-gearbox-high-torque-gear-motor/32754119224.html?spm=2114.06010108.3.85.EfcagF&ws_ab_test=searchweb0_0,searchweb201602_1_10000073_10065_10068_10000074_10000132_10000033_10000030_10000026_10000175_10000126_10000023_10000129_10000123_10000507_432_10000505_10000407_10000068_10060_10062_10056_10055_10054_302_10000063_301_10059_10000120_10099_10000020_10000156_10000013_10000117_10103_10102_10000016_10000114_10096_10000111_10052_10053_10050_10107_10051_10106_10000097_10000094_10000433_10000090_10000147_10000091_10000144_10084_10000150_10000101_10083_10000100_10080_10000153_10000104_10082_10000045_10081_10110_10000108_10111_10112_10113_10114_10000089_10000086_10000083_10000042_10000135_10000080_10078_10000485_10079_10000039_10073_10000494_10000140_10070_10000036_10122_10000389_10123_10000451_10126_10124_10000187,searchweb201603_3,afswitch_1,ppcSwitch_5,single_sort_2_default&btsid=9b90cc22-cbe4-4892-a639-5f1d0ab4da7d&algo_expid=9475ebd0-9b07-4cde-8c6f-4e73565279d0-11&algo_pvid=9475ebd0-9b07-4cde-8c6f-4e73565279d0</div>Clémenthttps://wiki.electrolab.fr/Projets:Perso:Siege_dynamiqueProjets:Perso:Siege dynamique2017-02-27T13:44:43Z<p>Clément: /* Les actionneurs */</p>
<hr />
<div>'''Relance du projet par Limesle et Clem'''<br />
<br />
{{Project<br />
|name= Siège dynamique pour simulateur<br />
|author= [[User:Limesle|Limesle]]<br />
|proposal_date= 16/11/2012<br />
|abstract1=*Fabriquation d'un siège dynamique du type : [[http://www.racingfr.com/forum/index.php?showtopic=22814 Lien sur Racing.fr]]<br />
|abstract2=*Projet qui regroupe plusieurs compétences à développer : Electronique et mécanique<br />
|abstract3=*Projet qui peut fédérer d'autres membres par le plaisir<br />
|tags=dynamique, simulateur<br />
|where=à la maison<br />
|for_who= Ceux qui sont restés joueurs!<br />
|official_electrolab_project= no<br />
}}<br />
==Les buts poursuivis==<br />
#Produire un siège efficace dans sa dynamique (puissance vérins ou moteurs, réactivité etc ...)<br />
#Rester dans une enveloppe de prix raisonnable (à définir car très relatif tout ça)<br />
#Le projet doit être reproductible et donc bien documenté<br />
#La machine obtenue doit être suffisament sécure, pour le pilote comme pour les observateurs (Coupe circuit, cellule photo de franchissement ?)<br />
#Le résultat doit être adapté à différents jeux : simulation voiture et avion a minima, voire parapente et simulateur vol oiseau<br />
#Afin de permettre une bonne immersion, les périphériques et écrans devraient être solidaires du siège (ex : [[http://www.buzzmoica.fr/video/jeu-simulation-formule1-sur-verins-hydrauliques-11418 vidéo]])<br />
# autre solution : google cardboard ou Oculus Rift ou autre HTC Vive<br />
<br />
<br />
Les rubriques liées au développement seront :<br />
*La structure support<br />
*Les actionneurs<br />
*Les périphériques électroniques (Ordi et écran compris)<br />
*La carte de control<br />
*La programmation et les signaux et/ou informations émis par les jeux et à traduire en mouvement<br />
<br />
<br />
==Les informations de départ==<br />
Etat des lieux de la "science"<br />
Birdly de Somniacs [[https://www.youtube.com/watch?v=gWLHIusLWOc&t=77s]]<br />
Hypersuit de Theory [[https://www.youtube.com/watch?v=0WpB_nzeocM]]<br />
<br />
Cabine 360 [[https://www.youtube.com/watch?v=TokSLPB5_Bs]]<br />
[[https://www.xsimulator.net/community/threads/x-sim-360%C2%B0-2dof-motion-flight-pit-with-arduino-for-dcs-world.7224/]]<br />
<br />
Exemple d'écrans high tech : [[https://www.youtube.com/watch?v=xBE16eBJK6E&t=3s]]<br />
<br />
==L'électronique force feedback==<br />
Exemple 2DOS avec base simple et arduino :[[http://www.etr.fr/tutorial/1353-fabriquer-un-simulateur-pour-moins-de-450.html]]<br />
<br />
==Les softs de transfert info Jeu vers actionneurs==<br />
*[[https://www.xsimulator.net/]]<br />
*[[http://x-sim.de/forum/portal.php]]<br />
<br />
<br />
==Les actionneurs==<br />
<br />
===Vérins===<br />
Système par vérin double entrée pour avoir toutes les positions possibles.<br />
*[[Robotique:Equipement#Verrin|Les vérins pneumatiques en robotique]]<br />
*[[http://fr.wikipedia.org/wiki/V%C3%A9rin Vérins sur Wikipédia]]<br />
*[[http://www.festo.com/cms/fr_fr/index.htm FESTO]]<br />
<br />
Exemple à vérin pneumatiques<br />
<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques :<br />
<br />
===Moteurs Pas à Pas===<br />
<br />
===Gyroscopes===<br />
<br />
= Les différents types de machines =<br />
<br />
== Types de plateforme ==<br />
=== 2 DoF ===<br />
<br />
=== 3 DoF ===<br />
<br />
== Type rotations ==<br />
=== 2 DoF Joyrider ===<br />
<br />
=== 2 DoF 360° ===<br />
Exemple du R360 de SEGA, à 2 axes en révolution complète<br />
*Vidéo : [[http://www.youtube.com/watch?v=FVbmoF9Ehuk]]<br />
*Lien Wikipédia : [[http://en.wikipedia.org/wiki/R-360]]<br />
*Site techniques : [[http://www.gameroomrepair.com/R360/R360.htm]] et [[http://www.system16.com/hardware.php?id=844]]</div>Clémenthttps://wiki.electrolab.fr/Projets:HexArcadeProjets:HexArcade2017-01-06T15:09:39Z<p>Clément: /* proof of concept */</p>
<hr />
<div>= Actus =<br />
* 2015/11/1: Prototypage<br />
* Démontage & réflexions pour réalisation sticks<br />
* Achat deux joysticks + boutons [http://www.starcab.net ici].<br />
* Démarrage projet.<br />
<br />
= Introduction =<br />
Il s'agit de réaliser une borne d'arcade générique, prévue pour six joueurs. D'inspiration directe du [http://www.djeff.net/pentapong.php pentapong], vu lors d'une visite du computerspiele museum à Berlin. <br />
<br />
[[File:Hexarcade-pentapong-original.jpg|300px]] Ceci est le PentaPong d'origine. L'objectif du présent projet est de faire le même genre de chose en hexagonal, et avec plus de jeux.<br />
<br />
<br />
== Objectifs ==<br />
On souhaite concevoir et réaliser une borne d'arcade utilisable pour six joueurs. L'objectif est d'en installer un exemplaire dans le hall d'accueil du lab v2 notamment, et de se servir de cette plateforme pour expérimenter différents gameplay particuliers.<br />
<br />
== Principes ==<br />
On intègre un PC dans une table hexagonale, incluant 6 controleurs customisés pour disposer de 6 directions. Tous les jeux proposés sont axés autour de ce form factor spécifique.<br />
<br />
Fonctionnellement, les controlleurs sont vus comme des claviers, et mappés en logiciel.<br />
<br />
Les jeux sont adaptés à cette plateforme, qui d'ailleurs peut servir de support pour se frotter à la programmation de jeux.<br />
<br />
== Fonctionnalités ==<br />
=== hardware===<br />
*Joystick arcade modifié pour avoir 6 directions<br />
*4 boutons classiques.<br />
*controlleur type arduilol (32u4 based)=>usb, avec HID joystick<br />
*chaque joystick + 4 boutons est indépendant, pour disposer d'une meilleure modularité.<br />
*écran x" disposé à l'horizontal, intégré dans une table hexagonale. A terme peut être vidéoprojecteur pour intégration meilleure..?<br />
*PC ou équivalent quelconque.<br />
<br />
=== software ===<br />
<br />
Un article vraiment bien sur comment gérer les grilles hexagonales dans les jeux: http://www.redblobgames.com/grids/hexagons/<br />
<br />
Quelques idées de jeux: <br />
<br />
- [http://www.java-gaming.org/index.php?topic=32981.0 Armor Critical] probablement mignon en split screen hexagonal<br />
<br />
== Module Joystick ==<br />
=== pré-étude ===<br />
Il faut modifier un joystick du commerce pour obtenir 6 directions.<br />
On cable 4 boutons classiques arcade.<br />
On peut faire une arduilol custom si nécessaire (type leonardo cheapo).<br />
On peut envisager de réaliser d'autres types de controleurs (volant, etc) pour des jeux différents... mais ce sera pour plus tard !<br />
<br />
=== proof of concept ===<br />
<br />
== Module table ==<br />
=== pré-étude ===<br />
* Structure en bois toute bête ; prévoir cependant un truc assez robuste pour survivre aux maltraitances des joueurs.<br />
* intégration du PC, de l'écran (CRT pour meilleurs angles de vision?), des joysticks.<br />
<br />
=== proof of concept ===<br />
Pour l'écran, imaginons prendre une dalle LCD toute bête, que l'on cale sur une planche découpée en hexagone, avec une fenetre de visu en hexagone, et des emplacements pour les 6 ensembles stick+boutons. En gros, voici le crobard:<br />
<br />
[[File:Hexarcade_table_crobar20170106_144430.jpg|600px]]<br />
<br />
Prochaine étape: dans une plaque de MDF ou autre d'épaisseur suffisante, tailler la table supérieure: découpe intérieure pour l'affichage, percages pour boutons + sticks + papattes pour "pieds de table" et on pistocollera un écran au dos...<br />
<br />
<br />
==== ecran 4/3 19" ====<br />
Prenons http://www.ldlc.com/fiche/PB00151513.html qui est un 19" à 150€. Peut être que l'angle de vue est pas génial, ou autre spec. Pour l'instant, on s'en tape.<br />
<br />
Calculs:<br />
* Ecran 4/3, diagonale 19", taille de dalle effective: x=11.4" (hauteur) et y=15.2" (largeur)<br />
* Si on aligne l'hexagone (inscrit dans cercle de rayon R) "à l'horizontale" en prenant toute la longueur, on a 2R = y = 15.2" => R=7.6".<br />
* La hauteur est donc cos(30°)*7.6=6.58, ca fait plus que 2*x, la hauteur est donc l'élément limitant!<br />
* Si on met l'hexagone "à l'horizontale" toujours, mais cette fois ci au lieu de prendre toute la largeur, on ajuste sur la hauteur, on a un hexagone visible inscrit dans un cercle de rayon R = x/2 / cos(30°) = 6.58" ce qui est inférieur à y/2<br />
<br />
Sur un écran 19", on case donc pas un hexagone très grand: 33cm de diamètre (taille pizza standard, quoi). Peut être suffisant pour un POC, mais la vraie version devra intégrer un vidéoprojecteur ou un écran plus grand, probablement...<br />
<br />
La taille de la table supérieure est donc:<br />
* hexagone inscrit dans un cercle de 33cm de diametre au centre pour zone d'affichage<br />
* 19" de diagonale pour la dalle, donc la zone "pour les manettes" doit être au delà. Disons pour simplifier et vu qu'on peut tricher et décaler, qu'il y a 20" de rayon pris par l'écran, et qu'il faut 4" pour loger les manettes : hexagone extérieur 28" de diamètre soit 70cm. Si on a un rectangle de 70x60cm, on arrive à caler le tout.<br />
<br />
==== ecran 16/9 24" ====<br />
Calculs:<br />
* diagonale 24", taille de dalle issue de x²+y²=24² et x=(16/9)*y on trouve x=11.76" et y=20.91"<br />
* on aligne l'hexagone de visu "à l'horizontale", l'élément limitant sera probablement la hauteur, égale à (x/2)/cos(30°) soit 6.79"<br />
* dans la largeur, on a donc 13.58" ce qui est très inférieur à y, on s'en doutait c'est un 16/9e et déjà un 4/3 c'est la hauteur qui est limitante!<br />
* on a donc l'hexagone de visu dans un cercle de diamètre 13.58" soit 34.5cm environ.<br />
* le cercle "de zone réservée à l'écran" est un cercle de diametre 24"+1" (pour viser large) soit 62.5cm<br />
* on prend encore une fois une bande de 4" pour les manettes & boutons, soit 29" de diamètre total, soit 72.5<br />
<br />
Bon au final, ca change pas la face du monde de prendre une dalle 4/3 ou 16/9...<br />
<br />
= Réalisation =<br />
== Electronique joystick ==<br />
Pour prototyper, on va réaliser un shield pour arduino leonardo. Requirement:<br />
* 6 boutons direction<br />
* 4 boutons action<br />
* connectique porc bornier a vis<br />
* Pilotage de leds<br />
<br />
<br />
On peut ptet utiliser une teensy, qui intègre directement le biniou pour faire un joy USB.<br />
<br />
== Firmware joystick ==<br />
[http://www.instructables.com/id/Add-USB-Game-Controller-to-Arduino-LeonardoMicro/ ressource pour le firmware]. Pour info ca ne compile pas en l'état, il faut faire quelques modifs à la machette pour que ca marche.<br />
<br />
<br />
On peut ptet utiliser une teensy, qui intègre directement le biniou pour faire un joy USB.<br />
<br />
== Hardware joystick ==<br />
On va tenter de modifier un joystick de borne d'arcade du commerce, car plus robuste. Il faudra fabriquer des pièces d'adaptation pour monter 6 switchs au lieu de 4.<br />
<br />
<br />
Fichiers 3D à imprimer ici: https://www.dropbox.com/sh/iz0l7rsaomcbaxw/AABz8me5P4Y5HQKkWfNki_B1a?dl=0 attentions, retouches à faire.<br />
<br />
<br />
[[File:Hexarcade_vueJoy.jpg|400px|center|thumb]]<br />
<center>Vue arrière du joystick à modifier</center><br />
<br />
[[File:Hexarcade_joyModif8crobar.jpg|400px|center|thumb]]<br />
<center>Crobard de principe pièce d'adaptation 6-way</center><br />
<br />
[[File:Hexarcade_CAD_Piece_joystick.JPG|400px|center|thumb]]<br />
<center>CAD de la pièce correspondante, merci Audran!</center><br />
<br />
[[File:Hexarcade_CAD_Piece_capot.JPG|400px|center|thumb]]<br />
<center>CAD de la pièce capot, merci Audran!</center><br />
<br />
[[File:Hexarcade_firstJoy.jpg|400px|center|thumb]]<br />
<center>La pièce imprimée et montée, merci Vincent!</center><br />
<br />
[[File:Hexarcade_firstJoy_closeup.jpg|400px|center|thumb]]<br />
<center>Closeup de la même pièce</center><br />
<br />
Yapluca cabler le bouzin et voir ce que ca donne. Peut etre qu'on pourrait avoir envie de rotater l'hexagone de 30° histoire qu'en position extreme (dans un angle) on ne switch qu'un bouton... Maiiis en l'état on devrait arriver à en faire quelque chose!<br />
<br />
= Ressources =<br />
* sparkfun stuff:<br />
**https://www.sparkfun.com/products/9337 bouton arcade bleu, <$2<br />
**https://www.sparkfun.com/products/9338 jaune<br />
**https://www.sparkfun.com/products/9341 vert<br />
**https://www.sparkfun.com/products/9336 rouge<br />
**https://www.sparkfun.com/products/9136 joystick 1: modifiable..?<br />
**https://www.sparkfun.com/products/9182 joystick 2: modifiable..?<br />
<br />
* pentapong (trouver la ref/ajouter des pics.)<br />
<br />
== Starcab ==<br />
<br />
[[File:Hexarcade_stuff.jpg|400px|center|thumb]]<br />
<center>Finalement, achat de quelques pièces pour tester</center><br />
<br />
'''Stick'''<br />
Stick le moins cher, avec boule changeable (pour mettre des couleurs differentes<br />
Switchable 2 - 4 - 8<br />
Microswitches inclus<br />
<br />
http://www.starcab.net/product_info.php?cPath=219_246&products_id=885<br />
<br />
'''Boutons standards'''<br />
28mm, Microswitch inclus, vissable<br />
6 couleurs.<br />
[[File:Hexarcade_bouton.jpg|400px|center|thumb]]<br />
<center>Bouton et switch</center><br />
[[File:Hexarcade_boutons.jpg|400px|center|thumb]]<br />
<center>Lot de boutons</center><br />
<br />
<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=521<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=520<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=518<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=519<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=523<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=524<br />
<br />
Prendre du rab pour les boutons start et autres trucs de maintenance eventuels. ( 10 boutons)<br />
<br />
== Macro-planning ==<br />
*HW: lister le stuff, commander le stuff, assembler le stuff. Jnat & clem dès que ya du temps<br />
*SW: chopper un framework sympa, installer un PC kivabien: emptty ; gameplay & premiers protos de jeu: emptty/jnat</div>Clémenthttps://wiki.electrolab.fr/Projets:HexArcadeProjets:HexArcade2017-01-06T14:01:38Z<p>Clément: /* proof of concept */</p>
<hr />
<div>= Actus =<br />
* 2015/11/1: Prototypage<br />
* Démontage & réflexions pour réalisation sticks<br />
* Achat deux joysticks + boutons [http://www.starcab.net ici].<br />
* Démarrage projet.<br />
<br />
= Introduction =<br />
Il s'agit de réaliser une borne d'arcade générique, prévue pour six joueurs. D'inspiration directe du [http://www.djeff.net/pentapong.php pentapong], vu lors d'une visite du computerspiele museum à Berlin. <br />
<br />
[[File:Hexarcade-pentapong-original.jpg|300px]] Ceci est le PentaPong d'origine. L'objectif du présent projet est de faire le même genre de chose en hexagonal, et avec plus de jeux.<br />
<br />
<br />
== Objectifs ==<br />
On souhaite concevoir et réaliser une borne d'arcade utilisable pour six joueurs. L'objectif est d'en installer un exemplaire dans le hall d'accueil du lab v2 notamment, et de se servir de cette plateforme pour expérimenter différents gameplay particuliers.<br />
<br />
== Principes ==<br />
On intègre un PC dans une table hexagonale, incluant 6 controleurs customisés pour disposer de 6 directions. Tous les jeux proposés sont axés autour de ce form factor spécifique.<br />
<br />
Fonctionnellement, les controlleurs sont vus comme des claviers, et mappés en logiciel.<br />
<br />
Les jeux sont adaptés à cette plateforme, qui d'ailleurs peut servir de support pour se frotter à la programmation de jeux.<br />
<br />
== Fonctionnalités ==<br />
=== hardware===<br />
*Joystick arcade modifié pour avoir 6 directions<br />
*4 boutons classiques.<br />
*controlleur type arduilol (32u4 based)=>usb, avec HID joystick<br />
*chaque joystick + 4 boutons est indépendant, pour disposer d'une meilleure modularité.<br />
*écran x" disposé à l'horizontal, intégré dans une table hexagonale. A terme peut être vidéoprojecteur pour intégration meilleure..?<br />
*PC ou équivalent quelconque.<br />
<br />
=== software ===<br />
<br />
Un article vraiment bien sur comment gérer les grilles hexagonales dans les jeux: http://www.redblobgames.com/grids/hexagons/<br />
<br />
Quelques idées de jeux: <br />
<br />
- [http://www.java-gaming.org/index.php?topic=32981.0 Armor Critical] probablement mignon en split screen hexagonal<br />
<br />
== Module Joystick ==<br />
=== pré-étude ===<br />
Il faut modifier un joystick du commerce pour obtenir 6 directions.<br />
On cable 4 boutons classiques arcade.<br />
On peut faire une arduilol custom si nécessaire (type leonardo cheapo).<br />
On peut envisager de réaliser d'autres types de controleurs (volant, etc) pour des jeux différents... mais ce sera pour plus tard !<br />
<br />
=== proof of concept ===<br />
<br />
== Module table ==<br />
=== pré-étude ===<br />
* Structure en bois toute bête ; prévoir cependant un truc assez robuste pour survivre aux maltraitances des joueurs.<br />
* intégration du PC, de l'écran (CRT pour meilleurs angles de vision?), des joysticks.<br />
<br />
=== proof of concept ===<br />
Pour l'écran, imaginons prendre une dalle LCD toute bête, 4/3 histoire d'utiliser le plus de dalle possible dans l'hexagone.<br />
<br />
Prenons http://www.ldlc.com/fiche/PB00151513.html qui est un 19" à 150€. Peut être que l'angle de vue est pas génial, ou autre spec. Pour l'instant, on s'en tape.<br />
<br />
Calculs:<br />
* Ecran 4/3, diagonale 19", taille de dalle effective: x=11.4" (hauteur) et y=15.2" (largeur)<br />
* Si on aligne l'hexagone (inscrit dans cercle de rayon R) "à l'horizontale" en prenant toute la longueur, on a 2R = y = 15.2" => R=7.6".<br />
* La hauteur est donc cos(30°)*7.6=6.58, ca fait plus que 2*x, la hauteur est donc l'élément limitant!<br />
* Si on met l'hexagone "à l'horizontale" toujours, mais cette fois ci au lieu de prendre toute la largeur, on ajuste sur la hauteur, on a un hexagone visible inscrit dans un cercle de rayon R = x/2 / cos(30°) = 6.58" ce qui est inférieur à y/2<br />
<br />
Sur un écran 19", on case donc pas un hexagone très grand: 33cm de diamètre (taille pizza standard, quoi). Peut être suffisant pour un POC, mais la vraie version devra intégrer un vidéoprojecteur ou un écran plus grand, probablement...<br />
<br />
La taille de la table supérieure est donc:<br />
* hexagone inscrit dans un cercle de 33cm de diametre au centre pour zone d'affichage<br />
* 19" de diagonale pour la dalle, donc la zone "pour les manettes" doit être au delà. Disons pour simplifier et vu qu'on peut tricher et décaler, qu'il y a 20" de rayon pris par l'écran, et qu'il faut 4" pour loger les manettes : hexagone extérieur 28" de diamètre soit 70cm. Si on a un rectangle de 70x60cm, on arrive à caler le tout.<br />
<br />
En gros, voici le crobard:<br />
<br />
[[File:Hexarcade_table_crobar20170106_144430.jpg|600px]]<br />
<br />
Prochaine étape: dans une plaque de MDF ou autre d'épaisseur suffisante, tailler la table supérieure: découpe intérieure pour l'affichage, percages pour boutons + sticks + papattes pour "pieds de table" et on pistocollera un écran au dos...<br />
<br />
= Réalisation =<br />
== Electronique joystick ==<br />
Pour prototyper, on va réaliser un shield pour arduino leonardo. Requirement:<br />
* 6 boutons direction<br />
* 4 boutons action<br />
* connectique porc bornier a vis<br />
* Pilotage de leds<br />
<br />
<br />
On peut ptet utiliser une teensy, qui intègre directement le biniou pour faire un joy USB.<br />
<br />
== Firmware joystick ==<br />
[http://www.instructables.com/id/Add-USB-Game-Controller-to-Arduino-LeonardoMicro/ ressource pour le firmware]. Pour info ca ne compile pas en l'état, il faut faire quelques modifs à la machette pour que ca marche.<br />
<br />
<br />
On peut ptet utiliser une teensy, qui intègre directement le biniou pour faire un joy USB.<br />
<br />
== Hardware joystick ==<br />
On va tenter de modifier un joystick de borne d'arcade du commerce, car plus robuste. Il faudra fabriquer des pièces d'adaptation pour monter 6 switchs au lieu de 4.<br />
<br />
<br />
Fichiers 3D à imprimer ici: https://www.dropbox.com/sh/iz0l7rsaomcbaxw/AABz8me5P4Y5HQKkWfNki_B1a?dl=0 attentions, retouches à faire.<br />
<br />
<br />
[[File:Hexarcade_vueJoy.jpg|400px|center|thumb]]<br />
<center>Vue arrière du joystick à modifier</center><br />
<br />
[[File:Hexarcade_joyModif8crobar.jpg|400px|center|thumb]]<br />
<center>Crobard de principe pièce d'adaptation 6-way</center><br />
<br />
[[File:Hexarcade_CAD_Piece_joystick.JPG|400px|center|thumb]]<br />
<center>CAD de la pièce correspondante, merci Audran!</center><br />
<br />
[[File:Hexarcade_CAD_Piece_capot.JPG|400px|center|thumb]]<br />
<center>CAD de la pièce capot, merci Audran!</center><br />
<br />
[[File:Hexarcade_firstJoy.jpg|400px|center|thumb]]<br />
<center>La pièce imprimée et montée, merci Vincent!</center><br />
<br />
[[File:Hexarcade_firstJoy_closeup.jpg|400px|center|thumb]]<br />
<center>Closeup de la même pièce</center><br />
<br />
Yapluca cabler le bouzin et voir ce que ca donne. Peut etre qu'on pourrait avoir envie de rotater l'hexagone de 30° histoire qu'en position extreme (dans un angle) on ne switch qu'un bouton... Maiiis en l'état on devrait arriver à en faire quelque chose!<br />
<br />
= Ressources =<br />
* sparkfun stuff:<br />
**https://www.sparkfun.com/products/9337 bouton arcade bleu, <$2<br />
**https://www.sparkfun.com/products/9338 jaune<br />
**https://www.sparkfun.com/products/9341 vert<br />
**https://www.sparkfun.com/products/9336 rouge<br />
**https://www.sparkfun.com/products/9136 joystick 1: modifiable..?<br />
**https://www.sparkfun.com/products/9182 joystick 2: modifiable..?<br />
<br />
* pentapong (trouver la ref/ajouter des pics.)<br />
<br />
== Starcab ==<br />
<br />
[[File:Hexarcade_stuff.jpg|400px|center|thumb]]<br />
<center>Finalement, achat de quelques pièces pour tester</center><br />
<br />
'''Stick'''<br />
Stick le moins cher, avec boule changeable (pour mettre des couleurs differentes<br />
Switchable 2 - 4 - 8<br />
Microswitches inclus<br />
<br />
http://www.starcab.net/product_info.php?cPath=219_246&products_id=885<br />
<br />
'''Boutons standards'''<br />
28mm, Microswitch inclus, vissable<br />
6 couleurs.<br />
[[File:Hexarcade_bouton.jpg|400px|center|thumb]]<br />
<center>Bouton et switch</center><br />
[[File:Hexarcade_boutons.jpg|400px|center|thumb]]<br />
<center>Lot de boutons</center><br />
<br />
<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=521<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=520<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=518<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=519<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=523<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=524<br />
<br />
Prendre du rab pour les boutons start et autres trucs de maintenance eventuels. ( 10 boutons)<br />
<br />
== Macro-planning ==<br />
*HW: lister le stuff, commander le stuff, assembler le stuff. Jnat & clem dès que ya du temps<br />
*SW: chopper un framework sympa, installer un PC kivabien: emptty ; gameplay & premiers protos de jeu: emptty/jnat</div>Clémenthttps://wiki.electrolab.fr/Projets:HexArcadeProjets:HexArcade2017-01-06T13:52:54Z<p>Clément: /* proof of concept */</p>
<hr />
<div>= Actus =<br />
* 2015/11/1: Prototypage<br />
* Démontage & réflexions pour réalisation sticks<br />
* Achat deux joysticks + boutons [http://www.starcab.net ici].<br />
* Démarrage projet.<br />
<br />
= Introduction =<br />
Il s'agit de réaliser une borne d'arcade générique, prévue pour six joueurs. D'inspiration directe du [http://www.djeff.net/pentapong.php pentapong], vu lors d'une visite du computerspiele museum à Berlin. <br />
<br />
[[File:Hexarcade-pentapong-original.jpg|300px]] Ceci est le PentaPong d'origine. L'objectif du présent projet est de faire le même genre de chose en hexagonal, et avec plus de jeux.<br />
<br />
<br />
== Objectifs ==<br />
On souhaite concevoir et réaliser une borne d'arcade utilisable pour six joueurs. L'objectif est d'en installer un exemplaire dans le hall d'accueil du lab v2 notamment, et de se servir de cette plateforme pour expérimenter différents gameplay particuliers.<br />
<br />
== Principes ==<br />
On intègre un PC dans une table hexagonale, incluant 6 controleurs customisés pour disposer de 6 directions. Tous les jeux proposés sont axés autour de ce form factor spécifique.<br />
<br />
Fonctionnellement, les controlleurs sont vus comme des claviers, et mappés en logiciel.<br />
<br />
Les jeux sont adaptés à cette plateforme, qui d'ailleurs peut servir de support pour se frotter à la programmation de jeux.<br />
<br />
== Fonctionnalités ==<br />
=== hardware===<br />
*Joystick arcade modifié pour avoir 6 directions<br />
*4 boutons classiques.<br />
*controlleur type arduilol (32u4 based)=>usb, avec HID joystick<br />
*chaque joystick + 4 boutons est indépendant, pour disposer d'une meilleure modularité.<br />
*écran x" disposé à l'horizontal, intégré dans une table hexagonale. A terme peut être vidéoprojecteur pour intégration meilleure..?<br />
*PC ou équivalent quelconque.<br />
<br />
=== software ===<br />
<br />
Un article vraiment bien sur comment gérer les grilles hexagonales dans les jeux: http://www.redblobgames.com/grids/hexagons/<br />
<br />
Quelques idées de jeux: <br />
<br />
- [http://www.java-gaming.org/index.php?topic=32981.0 Armor Critical] probablement mignon en split screen hexagonal<br />
<br />
== Module Joystick ==<br />
=== pré-étude ===<br />
Il faut modifier un joystick du commerce pour obtenir 6 directions.<br />
On cable 4 boutons classiques arcade.<br />
On peut faire une arduilol custom si nécessaire (type leonardo cheapo).<br />
On peut envisager de réaliser d'autres types de controleurs (volant, etc) pour des jeux différents... mais ce sera pour plus tard !<br />
<br />
=== proof of concept ===<br />
<br />
== Module table ==<br />
=== pré-étude ===<br />
* Structure en bois toute bête ; prévoir cependant un truc assez robuste pour survivre aux maltraitances des joueurs.<br />
* intégration du PC, de l'écran (CRT pour meilleurs angles de vision?), des joysticks.<br />
<br />
=== proof of concept ===<br />
Pour l'écran, imaginons prendre une dalle LCD toute bête, 4/3 histoire d'utiliser le plus de dalle possible dans l'hexagone.<br />
<br />
Prenons http://www.ldlc.com/fiche/PB00151513.html qui est un 19" à 150€. Peut être que l'angle de vue est pas génial, ou autre spec. Pour l'instant, on s'en tape.<br />
<br />
Calculs:<br />
* Ecran 4/3, diagonale 19", taille de dalle effective: x=11.4" (hauteur) et y=15.2" (largeur)<br />
* Si on aligne l'hexagone (inscrit dans cercle de rayon R) "à l'horizontale", on a 2R = 15.2" => R=7.6".<br />
* La hauteur est donc cos(30°)*7.6=6.58, ca fait plus que 2*x, la hauteur est donc l'élément limitant!<br />
* Si on met l'hexagone "à la verticale", on a R = x/2 / cos(30°) = 6.58" ce qui est inférieur à y/2<br />
<br />
Sur un écran 19", on case donc pas un hexagone très grand: 33cm de diamètre (taille pizza standard, quoi). Peut être suffisant pour un POC, mais la vraie version devra intégrer un vidéoprojecteur ou un écran plus grand, probablement...<br />
<br />
La taille de la table supérieure est donc:<br />
* hexagone inscrit dans un cercle de 33cm de diametre au centre pour zone d'affichage<br />
* 19" de diagonale pour la dalle, donc la zone "pour les manettes" doit être au delà. Disons pour simplifier et vu qu'on peut tricher et décaler, qu'il y a 20" de rayon pris par l'écran, et qu'il faut 4" pour loger les manettes : hexagone extérieur 28" de diamètre soit 70cm. Si on a un rectangle de 70x60cm, on arrive à caler le tout.<br />
<br />
En gros, voici le crobard:<br />
<br />
[[File:Hexarcade_table_crobar20170106_144430.jpg|600px]]<br />
<br />
Prochaine étape: dans une plaque de MDF ou autre d'épaisseur suffisante, tailler la table supérieure: découpe intérieure pour l'affichage, percages pour boutons + sticks + papattes pour "pieds de table" et on pistocollera un écran au dos...<br />
<br />
= Réalisation =<br />
== Electronique joystick ==<br />
Pour prototyper, on va réaliser un shield pour arduino leonardo. Requirement:<br />
* 6 boutons direction<br />
* 4 boutons action<br />
* connectique porc bornier a vis<br />
* Pilotage de leds<br />
<br />
<br />
On peut ptet utiliser une teensy, qui intègre directement le biniou pour faire un joy USB.<br />
<br />
== Firmware joystick ==<br />
[http://www.instructables.com/id/Add-USB-Game-Controller-to-Arduino-LeonardoMicro/ ressource pour le firmware]. Pour info ca ne compile pas en l'état, il faut faire quelques modifs à la machette pour que ca marche.<br />
<br />
<br />
On peut ptet utiliser une teensy, qui intègre directement le biniou pour faire un joy USB.<br />
<br />
== Hardware joystick ==<br />
On va tenter de modifier un joystick de borne d'arcade du commerce, car plus robuste. Il faudra fabriquer des pièces d'adaptation pour monter 6 switchs au lieu de 4.<br />
<br />
<br />
Fichiers 3D à imprimer ici: https://www.dropbox.com/sh/iz0l7rsaomcbaxw/AABz8me5P4Y5HQKkWfNki_B1a?dl=0 attentions, retouches à faire.<br />
<br />
<br />
[[File:Hexarcade_vueJoy.jpg|400px|center|thumb]]<br />
<center>Vue arrière du joystick à modifier</center><br />
<br />
[[File:Hexarcade_joyModif8crobar.jpg|400px|center|thumb]]<br />
<center>Crobard de principe pièce d'adaptation 6-way</center><br />
<br />
[[File:Hexarcade_CAD_Piece_joystick.JPG|400px|center|thumb]]<br />
<center>CAD de la pièce correspondante, merci Audran!</center><br />
<br />
[[File:Hexarcade_CAD_Piece_capot.JPG|400px|center|thumb]]<br />
<center>CAD de la pièce capot, merci Audran!</center><br />
<br />
[[File:Hexarcade_firstJoy.jpg|400px|center|thumb]]<br />
<center>La pièce imprimée et montée, merci Vincent!</center><br />
<br />
[[File:Hexarcade_firstJoy_closeup.jpg|400px|center|thumb]]<br />
<center>Closeup de la même pièce</center><br />
<br />
Yapluca cabler le bouzin et voir ce que ca donne. Peut etre qu'on pourrait avoir envie de rotater l'hexagone de 30° histoire qu'en position extreme (dans un angle) on ne switch qu'un bouton... Maiiis en l'état on devrait arriver à en faire quelque chose!<br />
<br />
= Ressources =<br />
* sparkfun stuff:<br />
**https://www.sparkfun.com/products/9337 bouton arcade bleu, <$2<br />
**https://www.sparkfun.com/products/9338 jaune<br />
**https://www.sparkfun.com/products/9341 vert<br />
**https://www.sparkfun.com/products/9336 rouge<br />
**https://www.sparkfun.com/products/9136 joystick 1: modifiable..?<br />
**https://www.sparkfun.com/products/9182 joystick 2: modifiable..?<br />
<br />
* pentapong (trouver la ref/ajouter des pics.)<br />
<br />
== Starcab ==<br />
<br />
[[File:Hexarcade_stuff.jpg|400px|center|thumb]]<br />
<center>Finalement, achat de quelques pièces pour tester</center><br />
<br />
'''Stick'''<br />
Stick le moins cher, avec boule changeable (pour mettre des couleurs differentes<br />
Switchable 2 - 4 - 8<br />
Microswitches inclus<br />
<br />
http://www.starcab.net/product_info.php?cPath=219_246&products_id=885<br />
<br />
'''Boutons standards'''<br />
28mm, Microswitch inclus, vissable<br />
6 couleurs.<br />
[[File:Hexarcade_bouton.jpg|400px|center|thumb]]<br />
<center>Bouton et switch</center><br />
[[File:Hexarcade_boutons.jpg|400px|center|thumb]]<br />
<center>Lot de boutons</center><br />
<br />
<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=521<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=520<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=518<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=519<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=523<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=524<br />
<br />
Prendre du rab pour les boutons start et autres trucs de maintenance eventuels. ( 10 boutons)<br />
<br />
== Macro-planning ==<br />
*HW: lister le stuff, commander le stuff, assembler le stuff. Jnat & clem dès que ya du temps<br />
*SW: chopper un framework sympa, installer un PC kivabien: emptty ; gameplay & premiers protos de jeu: emptty/jnat</div>Clémenthttps://wiki.electrolab.fr/File:Hexarcade_table_crobar20170106_144430.jpgFile:Hexarcade table crobar20170106 144430.jpg2017-01-06T13:52:14Z<p>Clément: </p>
<hr />
<div></div>Clémenthttps://wiki.electrolab.fr/Projets:HexArcadeProjets:HexArcade2017-01-06T13:00:10Z<p>Clément: /* Hardware joystick */</p>
<hr />
<div>= Actus =<br />
* 2015/11/1: Prototypage<br />
* Démontage & réflexions pour réalisation sticks<br />
* Achat deux joysticks + boutons [http://www.starcab.net ici].<br />
* Démarrage projet.<br />
<br />
= Introduction =<br />
Il s'agit de réaliser une borne d'arcade générique, prévue pour six joueurs. D'inspiration directe du [http://www.djeff.net/pentapong.php pentapong], vu lors d'une visite du computerspiele museum à Berlin. <br />
<br />
[[File:Hexarcade-pentapong-original.jpg|300px]] Ceci est le PentaPong d'origine. L'objectif du présent projet est de faire le même genre de chose en hexagonal, et avec plus de jeux.<br />
<br />
<br />
== Objectifs ==<br />
On souhaite concevoir et réaliser une borne d'arcade utilisable pour six joueurs. L'objectif est d'en installer un exemplaire dans le hall d'accueil du lab v2 notamment, et de se servir de cette plateforme pour expérimenter différents gameplay particuliers.<br />
<br />
== Principes ==<br />
On intègre un PC dans une table hexagonale, incluant 6 controleurs customisés pour disposer de 6 directions. Tous les jeux proposés sont axés autour de ce form factor spécifique.<br />
<br />
Fonctionnellement, les controlleurs sont vus comme des claviers, et mappés en logiciel.<br />
<br />
Les jeux sont adaptés à cette plateforme, qui d'ailleurs peut servir de support pour se frotter à la programmation de jeux.<br />
<br />
== Fonctionnalités ==<br />
=== hardware===<br />
*Joystick arcade modifié pour avoir 6 directions<br />
*4 boutons classiques.<br />
*controlleur type arduilol (32u4 based)=>usb, avec HID joystick<br />
*chaque joystick + 4 boutons est indépendant, pour disposer d'une meilleure modularité.<br />
*écran x" disposé à l'horizontal, intégré dans une table hexagonale. A terme peut être vidéoprojecteur pour intégration meilleure..?<br />
*PC ou équivalent quelconque.<br />
<br />
=== software ===<br />
<br />
Un article vraiment bien sur comment gérer les grilles hexagonales dans les jeux: http://www.redblobgames.com/grids/hexagons/<br />
<br />
Quelques idées de jeux: <br />
<br />
- [http://www.java-gaming.org/index.php?topic=32981.0 Armor Critical] probablement mignon en split screen hexagonal<br />
<br />
== Module Joystick ==<br />
=== pré-étude ===<br />
Il faut modifier un joystick du commerce pour obtenir 6 directions.<br />
On cable 4 boutons classiques arcade.<br />
On peut faire une arduilol custom si nécessaire (type leonardo cheapo).<br />
On peut envisager de réaliser d'autres types de controleurs (volant, etc) pour des jeux différents... mais ce sera pour plus tard !<br />
<br />
=== proof of concept ===<br />
<br />
== Module table ==<br />
=== pré-étude ===<br />
* Structure en bois toute bête ; prévoir cependant un truc assez robuste pour survivre aux maltraitances des joueurs.<br />
* intégration du PC, de l'écran (CRT pour meilleurs angles de vision?), des joysticks.<br />
<br />
=== proof of concept ===<br />
Pour l'écran, imaginons prendre une dalle LCD toute bête, 4/3 histoire d'utiliser le plus de dalle possible dans l'hexagone.<br />
<br />
Prenons http://www.ldlc.com/fiche/PB00151513.html qui est un 19" à 150€. Peut être que l'angle de vue est pas génial, ou autre spec. Pour l'instant, on s'en tape.<br />
<br />
Calculs:<br />
* Ecran 4/3, diagonale 19", taille de dalle effective: x=11.4" (hauteur) et y=15.2" (largeur)<br />
* Si on aligne l'hexagone (inscrit dans cercle de rayon R) "à l'horizontale", on a 2R = 15.2" => R=7.6".<br />
* La hauteur est donc cos(30°)*7.6=6.58, ca fait plus que 2*x, la hauteur est donc l'élément limitant!<br />
* Si on met l'hexagone "à la verticale", on a R = x/2 / cos(30°) = 6.58" ce qui est inférieur à y/2<br />
<br />
Sur un écran 19", on case donc pas un hexagone très grand: 33cm de diamètre (taille pizza standard, quoi). Peut être suffisant pour un POC, mais la vraie version devra intégrer un vidéoprojecteur ou un écran plus grand, probablement...<br />
<br />
La taille de la table supérieure est donc:<br />
* hexagone inscrit dans un cercle de 33cm de diametre au centre pour zone d'affichage<br />
* 19" de diagonale pour la dalle, donc la zone "pour les manettes" doit être au delà. Disons pour simplifier et vu qu'on peut tricher et décaler, qu'il y a 20" de rayon pris par l'écran, et qu'il faut 4" pour loger les manettes : hexagone extérieur 28" de diamètre soit 70cm. Si on a un rectangle de 70x60cm, on arrive à caler le tout.<br />
<br />
TODO: dans une plaque de MDF ou autre d'épaisseur suffisante, tailler la table supérieure: découpe intérieure pour l'affichage, percages pour boutons + sticks + papattes pour "pieds de table" et on pistocollera un écran au dos...<br />
<br />
= Réalisation =<br />
== Electronique joystick ==<br />
Pour prototyper, on va réaliser un shield pour arduino leonardo. Requirement:<br />
* 6 boutons direction<br />
* 4 boutons action<br />
* connectique porc bornier a vis<br />
* Pilotage de leds<br />
<br />
<br />
On peut ptet utiliser une teensy, qui intègre directement le biniou pour faire un joy USB.<br />
<br />
== Firmware joystick ==<br />
[http://www.instructables.com/id/Add-USB-Game-Controller-to-Arduino-LeonardoMicro/ ressource pour le firmware]. Pour info ca ne compile pas en l'état, il faut faire quelques modifs à la machette pour que ca marche.<br />
<br />
<br />
On peut ptet utiliser une teensy, qui intègre directement le biniou pour faire un joy USB.<br />
<br />
== Hardware joystick ==<br />
On va tenter de modifier un joystick de borne d'arcade du commerce, car plus robuste. Il faudra fabriquer des pièces d'adaptation pour monter 6 switchs au lieu de 4.<br />
<br />
<br />
Fichiers 3D à imprimer ici: https://www.dropbox.com/sh/iz0l7rsaomcbaxw/AABz8me5P4Y5HQKkWfNki_B1a?dl=0 attentions, retouches à faire.<br />
<br />
<br />
[[File:Hexarcade_vueJoy.jpg|400px|center|thumb]]<br />
<center>Vue arrière du joystick à modifier</center><br />
<br />
[[File:Hexarcade_joyModif8crobar.jpg|400px|center|thumb]]<br />
<center>Crobard de principe pièce d'adaptation 6-way</center><br />
<br />
[[File:Hexarcade_CAD_Piece_joystick.JPG|400px|center|thumb]]<br />
<center>CAD de la pièce correspondante, merci Audran!</center><br />
<br />
[[File:Hexarcade_CAD_Piece_capot.JPG|400px|center|thumb]]<br />
<center>CAD de la pièce capot, merci Audran!</center><br />
<br />
[[File:Hexarcade_firstJoy.jpg|400px|center|thumb]]<br />
<center>La pièce imprimée et montée, merci Vincent!</center><br />
<br />
[[File:Hexarcade_firstJoy_closeup.jpg|400px|center|thumb]]<br />
<center>Closeup de la même pièce</center><br />
<br />
Yapluca cabler le bouzin et voir ce que ca donne. Peut etre qu'on pourrait avoir envie de rotater l'hexagone de 30° histoire qu'en position extreme (dans un angle) on ne switch qu'un bouton... Maiiis en l'état on devrait arriver à en faire quelque chose!<br />
<br />
= Ressources =<br />
* sparkfun stuff:<br />
**https://www.sparkfun.com/products/9337 bouton arcade bleu, <$2<br />
**https://www.sparkfun.com/products/9338 jaune<br />
**https://www.sparkfun.com/products/9341 vert<br />
**https://www.sparkfun.com/products/9336 rouge<br />
**https://www.sparkfun.com/products/9136 joystick 1: modifiable..?<br />
**https://www.sparkfun.com/products/9182 joystick 2: modifiable..?<br />
<br />
* pentapong (trouver la ref/ajouter des pics.)<br />
<br />
== Starcab ==<br />
<br />
[[File:Hexarcade_stuff.jpg|400px|center|thumb]]<br />
<center>Finalement, achat de quelques pièces pour tester</center><br />
<br />
'''Stick'''<br />
Stick le moins cher, avec boule changeable (pour mettre des couleurs differentes<br />
Switchable 2 - 4 - 8<br />
Microswitches inclus<br />
<br />
http://www.starcab.net/product_info.php?cPath=219_246&products_id=885<br />
<br />
'''Boutons standards'''<br />
28mm, Microswitch inclus, vissable<br />
6 couleurs.<br />
[[File:Hexarcade_bouton.jpg|400px|center|thumb]]<br />
<center>Bouton et switch</center><br />
[[File:Hexarcade_boutons.jpg|400px|center|thumb]]<br />
<center>Lot de boutons</center><br />
<br />
<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=521<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=520<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=518<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=519<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=523<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=524<br />
<br />
Prendre du rab pour les boutons start et autres trucs de maintenance eventuels. ( 10 boutons)<br />
<br />
== Macro-planning ==<br />
*HW: lister le stuff, commander le stuff, assembler le stuff. Jnat & clem dès que ya du temps<br />
*SW: chopper un framework sympa, installer un PC kivabien: emptty ; gameplay & premiers protos de jeu: emptty/jnat</div>Clémenthttps://wiki.electrolab.fr/Projets:HexArcadeProjets:HexArcade2017-01-06T12:59:18Z<p>Clément: /* proof of concept */</p>
<hr />
<div>= Actus =<br />
* 2015/11/1: Prototypage<br />
* Démontage & réflexions pour réalisation sticks<br />
* Achat deux joysticks + boutons [http://www.starcab.net ici].<br />
* Démarrage projet.<br />
<br />
= Introduction =<br />
Il s'agit de réaliser une borne d'arcade générique, prévue pour six joueurs. D'inspiration directe du [http://www.djeff.net/pentapong.php pentapong], vu lors d'une visite du computerspiele museum à Berlin. <br />
<br />
[[File:Hexarcade-pentapong-original.jpg|300px]] Ceci est le PentaPong d'origine. L'objectif du présent projet est de faire le même genre de chose en hexagonal, et avec plus de jeux.<br />
<br />
<br />
== Objectifs ==<br />
On souhaite concevoir et réaliser une borne d'arcade utilisable pour six joueurs. L'objectif est d'en installer un exemplaire dans le hall d'accueil du lab v2 notamment, et de se servir de cette plateforme pour expérimenter différents gameplay particuliers.<br />
<br />
== Principes ==<br />
On intègre un PC dans une table hexagonale, incluant 6 controleurs customisés pour disposer de 6 directions. Tous les jeux proposés sont axés autour de ce form factor spécifique.<br />
<br />
Fonctionnellement, les controlleurs sont vus comme des claviers, et mappés en logiciel.<br />
<br />
Les jeux sont adaptés à cette plateforme, qui d'ailleurs peut servir de support pour se frotter à la programmation de jeux.<br />
<br />
== Fonctionnalités ==<br />
=== hardware===<br />
*Joystick arcade modifié pour avoir 6 directions<br />
*4 boutons classiques.<br />
*controlleur type arduilol (32u4 based)=>usb, avec HID joystick<br />
*chaque joystick + 4 boutons est indépendant, pour disposer d'une meilleure modularité.<br />
*écran x" disposé à l'horizontal, intégré dans une table hexagonale. A terme peut être vidéoprojecteur pour intégration meilleure..?<br />
*PC ou équivalent quelconque.<br />
<br />
=== software ===<br />
<br />
Un article vraiment bien sur comment gérer les grilles hexagonales dans les jeux: http://www.redblobgames.com/grids/hexagons/<br />
<br />
Quelques idées de jeux: <br />
<br />
- [http://www.java-gaming.org/index.php?topic=32981.0 Armor Critical] probablement mignon en split screen hexagonal<br />
<br />
== Module Joystick ==<br />
=== pré-étude ===<br />
Il faut modifier un joystick du commerce pour obtenir 6 directions.<br />
On cable 4 boutons classiques arcade.<br />
On peut faire une arduilol custom si nécessaire (type leonardo cheapo).<br />
On peut envisager de réaliser d'autres types de controleurs (volant, etc) pour des jeux différents... mais ce sera pour plus tard !<br />
<br />
=== proof of concept ===<br />
<br />
== Module table ==<br />
=== pré-étude ===<br />
* Structure en bois toute bête ; prévoir cependant un truc assez robuste pour survivre aux maltraitances des joueurs.<br />
* intégration du PC, de l'écran (CRT pour meilleurs angles de vision?), des joysticks.<br />
<br />
=== proof of concept ===<br />
Pour l'écran, imaginons prendre une dalle LCD toute bête, 4/3 histoire d'utiliser le plus de dalle possible dans l'hexagone.<br />
<br />
Prenons http://www.ldlc.com/fiche/PB00151513.html qui est un 19" à 150€. Peut être que l'angle de vue est pas génial, ou autre spec. Pour l'instant, on s'en tape.<br />
<br />
Calculs:<br />
* Ecran 4/3, diagonale 19", taille de dalle effective: x=11.4" (hauteur) et y=15.2" (largeur)<br />
* Si on aligne l'hexagone (inscrit dans cercle de rayon R) "à l'horizontale", on a 2R = 15.2" => R=7.6".<br />
* La hauteur est donc cos(30°)*7.6=6.58, ca fait plus que 2*x, la hauteur est donc l'élément limitant!<br />
* Si on met l'hexagone "à la verticale", on a R = x/2 / cos(30°) = 6.58" ce qui est inférieur à y/2<br />
<br />
Sur un écran 19", on case donc pas un hexagone très grand: 33cm de diamètre (taille pizza standard, quoi). Peut être suffisant pour un POC, mais la vraie version devra intégrer un vidéoprojecteur ou un écran plus grand, probablement...<br />
<br />
La taille de la table supérieure est donc:<br />
* hexagone inscrit dans un cercle de 33cm de diametre au centre pour zone d'affichage<br />
* 19" de diagonale pour la dalle, donc la zone "pour les manettes" doit être au delà. Disons pour simplifier et vu qu'on peut tricher et décaler, qu'il y a 20" de rayon pris par l'écran, et qu'il faut 4" pour loger les manettes : hexagone extérieur 28" de diamètre soit 70cm. Si on a un rectangle de 70x60cm, on arrive à caler le tout.<br />
<br />
TODO: dans une plaque de MDF ou autre d'épaisseur suffisante, tailler la table supérieure: découpe intérieure pour l'affichage, percages pour boutons + sticks + papattes pour "pieds de table" et on pistocollera un écran au dos...<br />
<br />
= Réalisation =<br />
== Electronique joystick ==<br />
Pour prototyper, on va réaliser un shield pour arduino leonardo. Requirement:<br />
* 6 boutons direction<br />
* 4 boutons action<br />
* connectique porc bornier a vis<br />
* Pilotage de leds<br />
<br />
<br />
On peut ptet utiliser une teensy, qui intègre directement le biniou pour faire un joy USB.<br />
<br />
== Firmware joystick ==<br />
[http://www.instructables.com/id/Add-USB-Game-Controller-to-Arduino-LeonardoMicro/ ressource pour le firmware]. Pour info ca ne compile pas en l'état, il faut faire quelques modifs à la machette pour que ca marche.<br />
<br />
<br />
On peut ptet utiliser une teensy, qui intègre directement le biniou pour faire un joy USB.<br />
<br />
== Hardware joystick ==<br />
On va tenter de modifier un joystick de borne d'arcade du commerce, car plus robuste. Il faudra fabriquer des pièces d'adaptation pour monter 6 switchs au lieu de 4.<br />
<br />
[[File:Hexarcade_vueJoy.jpg|400px|center|thumb]]<br />
<center>Vue arrière du joystick à modifier</center><br />
<br />
[[File:Hexarcade_joyModif8crobar.jpg|400px|center|thumb]]<br />
<center>Crobard de principe pièce d'adaptation 6-way</center><br />
<br />
[[File:Hexarcade_CAD_Piece_joystick.JPG|400px|center|thumb]]<br />
<center>CAD de la pièce correspondante, merci Audran!</center><br />
<br />
[[File:Hexarcade_CAD_Piece_capot.JPG|400px|center|thumb]]<br />
<center>CAD de la pièce capot, merci Audran!</center><br />
<br />
[[File:Hexarcade_firstJoy.jpg|400px|center|thumb]]<br />
<center>La pièce imprimée et montée, merci Vincent!</center><br />
<br />
[[File:Hexarcade_firstJoy_closeup.jpg|400px|center|thumb]]<br />
<center>Closeup de la même pièce</center><br />
<br />
Yapluca cabler le bouzin et voir ce que ca donne. Peut etre qu'on pourrait avoir envie de rotater l'hexagone de 30° histoire qu'en position extreme (dans un angle) on ne switch qu'un bouton... Maiiis en l'état on devrait arriver à en faire quelque chose!<br />
<br />
= Ressources =<br />
* sparkfun stuff:<br />
**https://www.sparkfun.com/products/9337 bouton arcade bleu, <$2<br />
**https://www.sparkfun.com/products/9338 jaune<br />
**https://www.sparkfun.com/products/9341 vert<br />
**https://www.sparkfun.com/products/9336 rouge<br />
**https://www.sparkfun.com/products/9136 joystick 1: modifiable..?<br />
**https://www.sparkfun.com/products/9182 joystick 2: modifiable..?<br />
<br />
* pentapong (trouver la ref/ajouter des pics.)<br />
<br />
== Starcab ==<br />
<br />
[[File:Hexarcade_stuff.jpg|400px|center|thumb]]<br />
<center>Finalement, achat de quelques pièces pour tester</center><br />
<br />
'''Stick'''<br />
Stick le moins cher, avec boule changeable (pour mettre des couleurs differentes<br />
Switchable 2 - 4 - 8<br />
Microswitches inclus<br />
<br />
http://www.starcab.net/product_info.php?cPath=219_246&products_id=885<br />
<br />
'''Boutons standards'''<br />
28mm, Microswitch inclus, vissable<br />
6 couleurs.<br />
[[File:Hexarcade_bouton.jpg|400px|center|thumb]]<br />
<center>Bouton et switch</center><br />
[[File:Hexarcade_boutons.jpg|400px|center|thumb]]<br />
<center>Lot de boutons</center><br />
<br />
<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=521<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=520<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=518<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=519<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=523<br />
http://www.starcab.net/product_info.php?cPath=219_165&products_id=524<br />
<br />
Prendre du rab pour les boutons start et autres trucs de maintenance eventuels. ( 10 boutons)<br />
<br />
== Macro-planning ==<br />
*HW: lister le stuff, commander le stuff, assembler le stuff. Jnat & clem dès que ya du temps<br />
*SW: chopper un framework sympa, installer un PC kivabien: emptty ; gameplay & premiers protos de jeu: emptty/jnat</div>Clémenthttps://wiki.electrolab.fr/Formations:Electronique:InitiationFormations:Electronique:Initiation2016-10-07T11:31:16Z<p>Clément: /* Contenu détaillé */</p>
<hr />
<div> Page en cours de creation...<br />
= Notions fondamentales d'électronique =<br />
Cette formation, en utilisant le prétexte d'ajouter un système d'éclairage sur un vélo, permet de découvrir ce qu'est l'électricité et l'électronique, en se penchant sur les notions fondamentales. Les outils indispensables sont également abordés.<br />
<br />
<br />
== Informations pratiques ==<br />
* Durée: 4h <br />
* Public visé: tous les membres souhaitant mieux comprendre ces notions fondamentales<br />
<br />
== Formations liées ==<br />
* Prérequis: culture générale<br />
* Formations suivantes: un grand nombre de possibilités offertes!<br />
<br />
== Matériel requis ==<br />
Ce que nous allons utiliser pour la partie mise en pratique: <br />
* bidules liés à l'éclairage vélo: câbles, boite pile, leds (blanches, rouges, oranges), résistances, interrupteurs, pièces mécaniques pour montage des éléments sur le vélo.<br />
* éventuellement, plaquette d'essai si on veut tester avec de vraies résistances, interrupteurs... sans passer par le projet vélo<br />
* multimètre, alimentation stable<br />
<br />
<br />
A noter que le lab dispose de tout le matériel nécessaire. Si vous voulez équiper votre propre vélo à l'issu de la formation, vous trouverez tous les éléments requis au lab, sous forme de kit.<br />
<br />
== Ressources additionnelles ==<br />
Supports externes/doc (à creuser/faire du ménage) :<br />
* ajouter liens pertinents, notamment... wikipedia.<br />
* https://wiki.analog.com/university/courses/electronics/text/electronics-toc<br />
* des trucs marrants ici:https://www.youtube.com/playlist?list=PL2EB473ED87C5561D<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectromagn%C3%A9tisme_et_%C3%A9lectricit%C3%A9<br />
<br />
= Contenu détaillé =<br />
Cette formation est prévue pour être animée au lab. Il est envisageable de suivre le plan en autoformation.<br />
<br />
Le slide-pack est en cours de création et sera mis à disposition ici ultérieurement.<br />
<br />
Il est prévu que les parties "théoriques" (en particulier le 1er chapitre) soit lu au calme avant la séance, et que la session de formation soit réservée aux questions et manipulations pratiques.<br />
<br />
Question: est-ce qu'il faut modifier le plan pour la rendre beaucoup, beaucoup plus "pratique" et orientée Arduino? Eg, l'électronique "autour d'un Arduino" plutôt que fondamentale.<br />
<br />
== Introduction ==<br />
Cette formation a pour objectif de rendre l'électricité et les concepts associés compréhensibles et utilisables.<br />
<br />
<br />
Le déroulé est le suivant:<br />
* C'est quoi au juste l'électricité ?<br />
** historique de sa découverte, et phénomènes physiques<br />
** la théorie: charge électrique et électromagnétisme<br />
** quel intérêt? quels usages?<br />
<br />
* Notions fondamentales:<br />
** courant/tension<br />
** circuit électrique, composants et schéma<br />
** caractéristique d'un composant et loi d'Ohm<br />
** outils: multimètre et alimentation stabilisée<br />
<br />
* Schémas usuels:<br />
** montage parallèle et série<br />
** lois de Kirshoff (loi des mailles, loi des nœuds)<br />
** pont diviseur de tension?<br />
** aspects puissance, thermique, énergie et ordres de grandeurs<br />
** diodes et caractéristiques non linéaires<br />
<br />
Pour la partie mise en pratique, on va concevoir (et potentiellement réaliser) un système d'éclairage de vélo : phares et veilleuse, allumage feux arrières lors de freinages. Les clignotants sont un peu au delà de ce qu'on saura faire à la fin, mais de pas grand chose.<br />
<br />
<br />
=== Pourquoi cette formation ===<br />
L'électricité et par extension l'électronique sont omniprésentes aujourd'hui. En particulier, une majorité de projets au lab nécessitent une forme de compréhension de ces notions. Même si à peu près tout le monde sait vaguement de quoi on parle, il n'est pas facile d'aborder avec précision ces sujets, tout en restant accessible à tous.<br />
<br />
<br />
== Chapitre 1 : C'est quoi l'électricité ? ==<br />
En utilisant l'angle des phénomènes physiques associés puis de la théorie la plus stricte, on va tenter de mieux comprendre ce qu'est l'électricité, comment elle se comporte et à quoi elle peut servir:<br />
* historique, et comment on l'observe<br />
* en théorie, c'est quoi<br />
* quel intérêt? quels usages?<br />
<br />
<br />
=== Phénomènes physiques observables et tâtonnements historiques ===<br />
Approche historique pour présenter les choses, c'est à dire comment on a découvert l’électricité & les atomes. Les phénomènes physiques observables: <br />
* éclairs<br />
* électricité statique<br />
* électromagnétisme<br />
* réactions chimiques<br />
<br />
=== La théorie ===<br />
Après de nombreux tâtonnements historiques, reprenons à la base, en fonction de l'état actuel des connaissances: l'électricité, c'est le déplacement de charges.<br />
* notion fondamentale de charge électrique : https://fr.wikipedia.org/wiki/Charge_%C3%A9lectrique<br />
* potentiel électrique: https://fr.wikipedia.org/wiki/Potentiel_%C3%A9lectrique<br />
* particule vecteur de charge la plus connue: l'électron. https://fr.wikipedia.org/wiki/%C3%89lectron Rapports avec la structure atomique. Autres vecteurs de charge: les ions.<br />
* Au final, l'étude de tout cela forme la branche de la physique qu'on appelle électromagnétisme: https://fr.wikipedia.org/wiki/%C3%89lectromagn%C3%A9tisme ; champ et force électrique: https://fr.wikipedia.org/wiki/Champ_%C3%A9lectrique champ et force magnétique https://fr.wikipedia.org/wiki/Champ_magn%C3%A9tique<br />
<br />
Pas facile à visualiser... on peut utiliser une analogie qui compare la charge avec la masse.<br />
* Dans un cours d'eau: goutte d'eau a une masse, à une altitude donnée.<br />
* Dans un courant électrique: chaque porteur de charge a une charge, à un potentiel donné.<br />
<br />
<br />
<br />
=== Quel intérêt ? quels usages ? ===<br />
Tout l'intérêt de l'électricité est dans ses interactions avec d'autres forces physiques, et en particulier l'énergie mécanique. L'électricité a l'avantage d'être un vecteur d'énergie très pratique : on peut stocker et transporter l'électricité beaucoup plus facilement que l'énergie mécanique.<br />
<br />
Comment on crée/stocke/transporte de l'électricité:<br />
* phénomènes chimiques, statiques, électromagnétiques => batterie, foudre, moteur<br />
* conducteurs électriques (fils, ...) et réseau secteur électrique<br />
<br />
Habituellement, ce qui nous intéresse dans l'électricité, c'est le déplacement de charges, plutôt qu'une accumulation de charges.<br />
=> courant/tension ; effets électromagnétiques (moteurs)<br />
<br />
On se sert de l'électricité pour faire tout un tas de conversions:<br />
* transformation d'énergie mécanique en énergie électrique dans une centrale, distribution dans un réseau électrique, puis utilisation pour faire tourner un moteur électrique (conversion dans l'autre sens)<br />
* apport d'énergie électrique pour modifier l'état chimique d'une pile lors de son rechargement, puis modification de l'état chimique d'une pile lorsqu'on en tire de l'énergie électrique pendant sa décharge. A noter que lorsqu'on charge la pile, on utilise au départ de l'énergie mécanique (à travers le réseau de distribution secteur), et souvent, on utilise à nouveau de l'énergie mécanique à la fin (moteur électrique).<br />
<br />
<br />
Il est primordial de bien comprendre la différence entre la puissance électrique (exprimée en Watts) et l'énergie (exprimée en Watts heure, même si ce n'est pas l'unité 'rigoureuse'). Exemple: un moteur de compresseur de frigo consomme lorsqu'il fonctionne 150W. S'il est en marche pendant une heure, il aura consommé 150Wh d'énergie. A noter qu'on convertit donc 150Wh d'énergie électrique (issue du réseau électrique) en énergie mécanique (compression du gaz dans le frigo pour le mécanisme de refroidissement).<br />
<br />
<br />
On fait parfois la distinction entre électricité et électronique: l'électronique est l'exploitation de l'électricité pour effectuer un transfert d'informations. L'électricité est le phénomène général, et parfois compris par opposition à l'électronique : lorsque l'électricité n'est utile que par le transfert d'énergie et pas d'information.<br />
<br />
<br />
En effet, l'électricité, au delà du transport d'énergie/de puissance, peut servir au transport d'informations. Deux grands modes de fonctionnement sont utilisés: information numérique (présence ou absence d'électricité) ou analogique (niveau de tension ou de courant). On parle dans un cas d'électronique numérique (ou digitale, par anglicisme), et d'électronique analogique de l'autre. Il existe encore d'autres subdivisions de l'électronique : électronique de puissance et électrotechnique (forte puissance, conversions d'énergie), électronique HF (hautes fréquences) ou RF (radio fréquences), microélectronique (miniaturisation de composants électronique), ... chacun de ces domaines emploie les même phénomènes physiques et repose sur les même règles fondamentales, que nous allons voir dans les chapitres suivants.<br />
<br />
Voir électronique niveau 2: analogique, électronique niveau 2: numérique, et autres formations.<br />
<br />
<br />
<br />
== Chapitre 2 : notions fondamentales ==<br />
* Notions fondamentales:<br />
** détails sur courant/tension<br />
** circuit électrique, composant et schéma<br />
** caractéristique d'un composant et loi d'Ohm<br />
<br />
<br />
* Outil: le multimètre (pour mesurer la tension et le courant)<br />
* Outil: l'alimentation stabilisée.<br />
* Pratique: mesure de caractéristique d'une R.<br />
* Pratique: circuit d'allumage du phare avant et veilleuses. Circuit de feu arrière de freinage.<br />
<br />
=== courant/tension ===<br />
*déplacement de charges (additivité, conservation). Phénomènes physiques intéressants liés au déplacement de charge: electromag, information.<br />
*analogie avec l'eau: débit et pression.<br />
*courant/tension: unités, ordres de grandeur<br />
*continu/alternatif.<br />
<br />
Pratique: le multimètre<br />
<br />
=== circuit électrique et schéma ===<br />
*Mouvements d'électrons: notion de circuit (rappel: cause ddp générée par electromag ou chimique, ou statique).<br />
*Notion de modèle/schématique. <br />
*qu'est ce qui "impose" le déplacement des charges et donc tension/courant? comprendre et prévoir.<br />
<br />
Pratique: alimentation stabilisée<br />
<br />
=== caractéristique d'un composant et loi d'Ohm ===<br />
Notion de composant/dipole/quadripole ; modélisation pour réfléchir/choisir le comportement, anticiper ce qu'il va se passer. Relations entre tensions et courant pour différents bidules. <br />
<br />
Exemple: une résistance.<br />
<br />
Pratique: caractéristique d'une résistance<br />
<br />
== Chapitre 3 : circuits usuels ==<br />
La plupart des schéma/circuits ne sont pas des boucles simples, mettent en oeuvre différents composants, aux caractéristiques parfois complexes.<br />
<br />
* Schémas usuels:<br />
** montage parallèle et série<br />
** lois de Kirshoff (loi des mailles, loi des nœuds)<br />
** pont diviseur de tension<br />
** aspects puissance, thermique, énergie et ordres de grandeurs<br />
** diodes et caractéristiques non linéaires<br />
<br />
=== Parallèle et série ===<br />
Résistances... avec manip.<br />
<br />
=== Lois de Kirshoff ===<br />
Lois de Kirshoff (loi des mailles, loi des noeuds). Thévenin/Norton: bof. Superposition: out.<br />
<br />
Exemples d'associations de résistances, calculs sur des circuits simples. Avec manip également ! => aspect prédictif de ces lois, et modèle satisfaisant pour réfléchir à ce qui se passe vs ce qu'on veut.<br />
<br />
=== Puissance, thermique, etc ===<br />
Pour aller plus loins/limites: d'autres cas pourris/ou les modeles simplistes ne marchent pas/ne suffisent pas: considérations de puissance et thermique, de résistance interne batterie, etc...<br />
<br />
=== diodes et caractéristique non linéaire ===<br />
Autre exemples: diodes et caractéristiques non linéaires ; autres composants avec des comportements phunkys (et donc intéressants) : bobines, condensateurs, transistors... y compris quand on en met plusieurs (circuit intégré genre NE555), voire PLEIN : électronique numérique. Autres sujets, renvois vers formations correspondantes.<br />
<br />
Manip: carac LED (courbe points de fonctionnement U/I)<br />
<br />
Cas pratique: application au vélo!<br />
<br />
Velo: batterie, switchs, résistances, leds<br />
* ajouter des leds et faire les veilleuses/eclairages genre phares<br />
* ajouter un circuit pour allumer feu arrière lors du freinage<br />
* clignotants: on est un peu embêtés... faut le faire à la mano (ou aller à la formation lvl2)<br />
<br />
velo: logique de clignotants (à la main.... mode volta :P) avec branche avant/arriere ; logique veilleuse/feu (eg phare avant, ou frein/veilleuse sur arriere) => switchs, parallèle, série, intensités (eg plus fort quand freine ou appel de phare... sur le meme truc!).<br />
<br />
<br />
== Conclusion ==<br />
Cette formation a permis: <br />
* de mieux comprendre ce qu'est l'électricité<br />
* d'aborder les notions fondamentales<br />
* d'examiner les circuits simples<br />
... et de faire un système d'éclairage vélo basique mais fonctionnel.<br />
<br />
La suite (par exemple) : <br />
* Animer vous même cette formation!<br />
* Autres formations: électronique numérique, analogique (lvl2: NE555, ampli op), puissance (transistors? moteurs?)<br />
* Ajouter des fonctions à l'éclairage du vélo<br />
<br />
=> Critiquez la formation, appropriez vous le contenu. <br />
<br />
A vous la parole (links pour feedback)</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:Initiation:EnFormations:Arduino:Initiation:En2016-10-04T14:59:55Z<p>Clément: /* Défi 4 : jouer avec les délais */</p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Introduction to microcontrollers with the Arduino platform =<br />
Arduino, the famous microcontroler board, makes it easy to hack embedded systems that involves sensors, actuators, programs.<br />
In this workshop, we'll discover what it can do: input, output, communication.<br />
To do so, we'll play with several challenges that an Arduino can easily solve.<br />
<br />
This workshop is open to everyone, and is intended as an help for your first steps in the Arduino world.<br />
<br />
<br />
== Info ==<br />
* Duration: 3h or more<br />
* Target audience: any Electrolab member, beginner level in computer programming/electronics/Arduino<br />
<br />
== Related trainings ==<br />
* prerequisite: nothing special, except ability to read & basic computer skills<br />
* Ideally:<br />
** basic notions of electronics : see corresponding [[Formations:Electronique:Initiation:En|training on this topic]]<br />
** basic notions of (computer) programming : see corresponding [[Formations:Programmation:Initiation:En|training on this topic]]<br />
<br />
* Following trainings:<br />
** My First Arduino Project<br />
<br />
== Equipment ==<br />
It is mandatory to bring your own laptop. You must install the Arduino software before the training. Please refer to https://www.arduino.cc/en/Main/Software<br />
<br />
Examples and exercices on this page use content from the Arduino starterkit, Electrolab version.<br />
This kit is sold 30€, and several kits are also available during the training<br />
<br />
Contents :<br />
* Arduino Nano + USB cable<br />
* breadboard (400p) and cables male/male et female/female<br />
* potentiometer and pushbutton (joystick)<br />
* leds: red, green, yellow, white, blue, RGB and resistor (x8) 330 ohm<br />
* photoresistor & thermistor + adapted resistor set (2x1k, 2x10k, 2x100k)<br />
* micro-servomotor, buzzer<br />
<br />
Warning: the Arduino nano board that we use require a special device driver ! These are dirtycheap clones made in China.<br />
<br />
=== IDE (software) installation ===<br />
(maybe move this section some place else?)<br />
* see https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide<br />
* please note that our boards require the ch340 device driver, that does not come with the IDE installation.<br />
See https://www.google.com/?q=ch340+driver to install the mandatory specific device driver without which our kits wont work<br />
<br />
== Additionnal info ==<br />
To buy equipment:<br />
* the Electrolab sells a few components & modules, additionnaly to the starterkit<br />
* many many shops sell Arduino stuff: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== About Arduino ===<br />
* On their website www.arduino.cc : [https://www.arduino.cc/en/Tutorial/HomePage tutorials] and also [https://www.arduino.cc/en/Tutorial/BuiltInExamples code examples with explanations] <br />
* [https://www.arduino.cc/en/Guide/HomePage a similar page to the one you're reading now], directly on the official website (not as good, of course ;)<br />
* [http://eduscol.education.fr/sti/sites/eduscol.education.fr.sti/files/ressources/techniques/3846/3846-les-cles-de-la-carte-esplora.pdf nice document about the esplora board]<br />
* French speaking reference website: http://eskimon.fr/<br />
* Check out website of shops: Sparkfun, Adafruit Industries, ... have lots of online ressource<br />
* deadtree book: I personnally find "Arduino for dummies" interesting.<br />
<br />
=== About programming ===<br />
* basic notions of computer programming : see our [[Formations:Programmation:Initiation:En|training on this topic]]<br />
* see [https://www.arduino.cc/en/Reference/HomePage this page for Arduino language & reference]<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_g%C3%A9n%C3%A9rale_%C3%A0_la_programmation and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_au_langage_C and similar english page.<br />
<br />
=== About electronics ===<br />
* basic notions of electronics: see our [[Formations:Electronique:Initiation:En|training on this topic]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|on our wiki]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectromagn%C3%A9tisme_et_%C3%A9lectricit%C3%A9 and similar english page.<br />
<br />
= Content of the training =<br />
This is designed to be a training at the Electrolab.<br />
One can probably follow along without coming to the actual training on site... but this page needs more work before this is a good option.<br />
Slides from the training will be published here later on.<br />
<br />
== Introduction ==<br />
This training intends to help you discover microcontrollers and how to use them, by using the Arduino platform.<br />
No special knowledge is required for this training: we'll see along everything we need. Of course, if you want to know more on the topic of electronics and computer programming, you should check out our trainings on these topics.<br />
<br />
Let's see what microcontrolers are, how to use them. This will open the gates to a vast diversity of projects !<br />
<br />
==== Preliminary: notions of electronics and computer programming ====<br />
In this training we'll use:<br />
* elecronics related concepts:<br />
** electricity, voltage/current<br />
** electronic circuit, schematic & component model<br />
* computer programming related concepts:<br />
** what is a computer program? a programming language? How to use this?<br />
** C language semantics and [https://www.arduino.cc/en/Reference/HomePage Arduino specific keywords].<br />
** workflow associated with computer programming: design, writing your program, compiling, testing & bug tracking, ...<br />
We have trainings on these topics.<br />
<br />
In any case, no need to be an expert to follow along the Arduino training: do not hesitate to ask questions along the way, including (most encouraged) to your neighbours.<br />
<br />
=== Microcontrollers ===<br />
To learn more, here's the manufacturer webpage of the central chip that we will use: http://www.atmel.com/devices/atmega328p.aspx<br />
<br />
The main technical reference document is its datasheet. This is a long but very interesting read, that you should at least check out quickly: http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf<br />
<br />
There are course material pages on there: https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR<br />
<br />
<br />
==== What is a microcontroller? ====<br />
A microcontroller is a type of chip that is widespread. It can be seen as a small computer that is all integrated on one silicon chip: processor (CPU), memory (RAM & flash), various input/output managers, various peripherals, ... all in one single tiny chip.<br />
This thing is thus capable of interacting closely with the real world: measure physical values with various sensors, and act upon the world by driving actuators. Inbetween sensing and actuating (input and output), the central processor makes "decisions": it executes the program that has been written by you or someone else, and thus follows strictly the behavior that has been described.<br />
<br />
This is a powerful thing: by just writing a different program, you can completely change the behavior of the system. It is also super flexible, because your program can be arbitrarily complex, and give an also arbitrarily complex behavior to the system.<br />
<br />
TODO: picture of the chip on the board: systemic view, with inputs, arrows, CPU+software, arrows, outputs<br />
<br />
==== What is a microprocessor? ====<br />
We also use the acronym: CPU, central processing unit. That's the thing at the heart of a computer, that executes the instructions corresponding to a program. These instructions are very simple:<br />
* add the value 42 to the memory location #3<br />
* if memory location #3 is zero, go execute instruction two locations lower in program memory.<br />
* otherwise, execute the one one location lower in program memory.<br />
<br />
It is not easy to give computers instructions at such a low level of absstraction (eg, assembly leve), because one has to know exactly what the CPU at hand can or cannot do, and how. Most importantly, it is impossible to give complex orders (with a high level of abstraction), like "display an image" or "compute the average value of a group of values". The natural tendency is to use programming language with more and more evolved, abstract, complex instructions (high level languages), that make the programmer's job easier.<br />
<br />
<br />
Physical implementation of a CPU is a fascinating topic: it's where the fronteer between hardware and software is blurry, and where the magic happens : let's keep it for the "introduction to digital electronics" training...<br />
<br />
==== What is binary and number of bits? ====<br />
CPU can handle only 0 and 1: these a digital circuits. To manipulate "real" number, we use base 2, which considers 1 and 0 as digits to represent any number. For example, the number 6 that you well know (formally, can be written as 6*10^0), can also be written as 2+4, or, with base 2: 1*2^2 + 1*2^1 + 0*2^0, or again 110 (base two). These digits that can be 0 or 1 are called bits, or binary digits.<br />
<br />
One major parameter of CPU design is the size of numbers it can natively handle: it depends on how many digits (bits) it can handle at once for a given number. For example, the microcontroler we use in these Arduino has an 8bits CPU: internally, it uses 8 digits numbers, each digit being either 0 or 1.<br />
<br />
So, that should mean the largest number it can handle is 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. Quite small!<br />
<br />
You may ask: what's up with negative numbers, decimal (eg 1.27) numbers, etc... there are ways to do this, but it isnt easy for a small CPU like the one in the Arduino's microcontroller.<br />
<br />
<br />
See:<br />
* https://fr.wikiversity.org/wiki/Code_de_num%C3%A9ration/Introduction or similar in english<br />
* https://fr.wikipedia.org/wiki/Virgule_fixe fixed point.<br />
* https://fr.wikipedia.org/wiki/IEEE_754 (floating point number representation: warning, this isnt an easy topic)<br />
<br />
==== What are they useful for? Where? ====<br />
Many things: interface sensors & actuators of any kind, and decide behavior through writing a programm makes it possible to create sooo many cool things. For example, a washing machine, a modern car, an elevator, ... many, most if not all everyday objects rely on a microcontroller to function as expected. It could be seen as the brain ot said object.<br />
<br />
TODO: picture of a simple system: input, output, software, for an everyday object.<br />
<br />
For example {any closed loop system, or finite state machine based system, that audience can relate to: washing machine, elevator, ...?)<br />
<br />
<br />
==== How to use it? ====<br />
* system design: first, think and make explicit what it is that you're trying to do. What input will you use, and how? Which outputs do you expect, and when? What is the overal expected behavior? What are the missions/goals?<br />
* hardware design: once this is all clear, design & create the hardware, create the schematic with selected sensors & actuators. It may make sense to separate clearly different modules, and perform hierarchical design: first learn how to get values from this sensor, then, tackle all issues specifically related to that motor, before trying to do everything at once.<br />
* software design: once your hardware is ready, you can work on software: here again, it probably makes sense to start with separate modules: divide to conquer applies here. Try out bits of software, think about your overall design before writing code.<br />
* Tests, bug tracking & modifications to the design: nothing ever works the first time...<br />
<br />
=== The Arduino platform & world ===<br />
Arduino has been design for students in design and artists, which means non specialists in electronics, computer science and embedded systems, to allow them to design and hack things that require a microcontroller. This means that "easy to get started with" is at the first position in the requirement list for Arduino. As we shall soon see, this is quite a success!<br />
<br />
Teaching support: create a tool that is easy to use and allows student to do stuff. Wiring is almost as important as Arduino (boards). Is based on free software, and is itself free, too (as in free speech, not free beer: you still have to buy the boards)<br />
<br />
==== What is Arduino ? ====<br />
Compared to the many boards & platforms that existed before Arduino, several aspects make it 100% more awesome:<br />
* Opensource: it relies on existing opensource projects, and everything that has been added is also published under free licenses. This has the usual advantages of free software.<br />
* Cheap: by design, the board had to cost not more than one meal. Being affordable allows people to actually get one and play with it without the fear to destroy it. It began at around 20€ per board, which was 5x cheaper than similar platforms. Now, dirtycheap clones cost few € each.<br />
* Not a toy or just a teaching contraption: they designed an easy to use and intuitive interface, shortcuts in the programming language, and a robust electronic board. BUT all this relies on "real" tools that professionnals use everyday, making them easier to use. This allows anyone to check what's under the hood after the first few steps, and get your hands dirty if you need or want to.<br />
<br />
All this worked well beyond initial plans, and a growing number of people started using Arduino, contribution upgrades, documenting projects, additionnal modules and features... today, the community is extremely active and powerful. There are an incredible number of sensors, actuators, code and project example out there for anyone to learn from and use in whatever project they like, making a wide range of project much, much easier to achieve.<br />
<br />
==== Anatomy of an Arduino electronic board ====<br />
Arduino nano board: picture, feature sheet, etc...<br />
<br />
In this training, we'll use an all integrated board: the Arduino Nano<br />
<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg picture of a Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png pinout of a Arduino Nano]<br />
<br />
==== Features of our Arduino board ====<br />
Added to the CPU (that executes the software that we write) and the memory (flash, to store the data even when the power is out, and RAM for the value we're working on), the microcontroler on the Arduino board knows various different tricks:<br />
* A bit more than ten inputs that we call "digital": the mcu can "see" the presence or absence of a voltage, at defined levels. Our program is able to read the value of the voltage on a pin that is configured as an input, and we can use the value read in our program. We use the term "high" and "low" level, for a voltage of 0v or 5v between that pin and the GND pin of the microcontroller.<br />
* These pins can also be configured as outputs: here, it is the CPU (and thus, our program) that forces the voltage level, either high (5v) or low (0v). Warning: there is a power limit on what each pin and the whole mcu can provide! Each pin can source (eg, it flows out of the chip) or sink (eg it flows in the chip) 20mA, not more. It is the power level required to light an average LED... moving an electric bike may require 1000 times more power: the mcu cannot do this without additionnal circuitry.<br />
* Analog voltage inputs (between 0v and 5v): the mcu we use has a very useful peripheral: an Analog Digital Converter. It can convert an analog voltage (here, between 0 and 5v) present on a specific input pin (6 of them on our board) into a value between 0 and 1023. Why this range? It uses 10 bits numbers. So for exemple, if there is a voltage of 2.5v on an analog input pin, the ADC will read a value of 512 (1023*2.5v/5v = 512).<br />
* For various reasons, there is no easy way to generate an output other than 0v or 5v... dont worry, we'll see how to achieve this with different tricks later !<br />
<br />
The mcu we use also contains all the required hardware to communicate with a computer. It also has lots of other peripherals and things more sophisticated, that can be learnt about later. Please read the datasheet, that is an exhaustive source of information on the chip's features.<br />
<br />
Note: it has enough RAM (to store variables) and flash memory (to store our program) for most of the applications we can work on.<br />
<br />
==== Use the software tool ====<br />
We use the Arduino IDE to write our program, compile (eg transform from human readable to machine usable) it and transfer it to the Arduino board memory through the USB connexion.<br />
<br />
<br />
* menus: chose board & port, access the example projects<br />
* buttons: upload, launch terminal/serial monitor<br />
* <br />
TODO: lots of pictures<br />
<br />
==== Software install ====<br />
'''Installation/verification of the IDE and driver.'''<br />
Note: this should be on anoter page..? just refer to the official page?<br />
<br />
TODO: pictures de partout.<br />
<br />
* howto install IDE : see official website<br />
* howto install driver: harder, as it seems that no website is stable enough as a reference...<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== What's in the starterkit? ===<br />
Let's check out the Arduino Starterkit contents.<br />
<br />
TODO: lots of pictures ; maybe link to other pages instead (eg doc of the kit)<br />
<br />
*Breadboard <br />
** describe how it works<br />
** explain how to create a circuit<br />
* component X: TODO<br />
<br />
== Outputs==<br />
Let's get our hands dirty with the output capabilities of the Arduino.<br />
The first example ever is to play with a LED.<br />
<br />
=== Turn on and off a LED ===<br />
<br />
==== "blink" example and basic functions ====<br />
Our first program is named "Blink", it blinks a LED. It is an example program provided by the Arduino IDE. It can be found in File/Example/Basics.<br />
<br />
Once you've opened this project, clic on the "upload" button to compile the code, and transfer the resulting binary into the mcu flash memory. As a result, the LED called "L", that is connected to pin 13 on an Arduino, blinks at a steady pace.<br />
<br />
This rather simple test is the traditionnal first step with any new mcu platform: congratulations, you've just made your first step with an Arduino :)<br />
<br />
<br />
'''Wiring:'''<br />
There is no need to do any type of wiring: everything that is required is already on the Arduino board we use!<br />
<br />
TODO: pictures.<br />
<br />
'''Understanding the schematic:'''<br />
The schematic is very simple: a LED is connected to the D13 pin of the mcu. There is a resistor in serie, to limit the current to an acceptable value. The LED is correctly oriented so that there is current flowing through it when the pin D13 is set at 'HIGH'.<br />
<br />
One can check [https://www.arduino.cc/en/uploads/Main/ArduinoNano30Schematic.pdf the Nano board schematic] to understand, check components values, etc. For example, the resistor is 330 ohm, one can guess that the LED has a threshold value of 2v, so when there's a HIGH value on D13 (eg 5v), there is 3v across the resistor, so a current flowing through it of 3/330 A, which is approximately 10mA: that's alright for a LED that can probably withtand currents up to 50mA, and the mcu that can do 20mA.<br />
<br />
TODO: picture schematic arduino output 13 +resistor + LED, current & voltage.<br />
<br />
'''Source code:'''<br />
Let's check the source code:<br />
* setup() is a function (bloc of instructions) that gets executed when the board powers up. It is useful to do all the setup that we need for our project. Here: explicit that pin 13 shall be an output (output: the MCU drives the state of that pin)<br />
* loop() is a funciton (bloc of instructions) that gets repetedly executed - as a loop. It contains four lines:<br />
** we turn the LED on by driving the pin D13 to HIGH<br />
** we wait for 1000 milliseconds, which is one second<br />
** we turn the LED off by driving the pin D13 to LOW<br />
** we wait for 1000 milliseconds, which is one second<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Challenge 1: change blinking speed ====<br />
Question: how can we change the speed at which the LED blinks?<br />
<br />
Not a theory question: try to change the code to have the LED blink at a different speed, and clic the upload button to check if your modification achieves your goal.<br />
<br />
Answer: {TODO: shall be hidden/spoiler protected!}<br />
* by changing the value 1000, we change the wait time after we turn the LED on and off. For example:<br />
** with the values 200 and 200, the LED blinks 5 times faster<br />
** with the values 2000 and 2000, the LED blinks 2 times slower<br />
** with 500 and 1500, the LED blinks at the same speed, but it is turned on for less long<br />
<br />
Result:<br />
* Understanding of a simple program<br />
* we've immediately done something real with that LED!<br />
<br />
==== Challenge 2: SOS in morse code ====<br />
Question: how can we create more complex blinking patterns? For example, let's do the famous "SOS" in morse code: ...---... which is three short flashes (code for 'S'), three long (code for 'O') and again three short flashes.<br />
<br />
Let's display this on the L LED!<br />
<br />
Remember: even on a simple example, a well structured and cleaned up program is much better.<br />
<br />
<br />
===== Answers to 2.1 =====<br />
* there are several different ways of achieving this:<br />
** copy paste the four lines of code we already know as many times as required, with changed values for the delay() function<br />
** create our own functions, like "short_flash()" and "long_flash()", or display_S() and display_O()<br />
* use parameterized code makes sense:<br />
** having "magic numbers" everywhere we use delay() is problematic: it isnt easy to change these values, and when reading the code, who knows why the value is 1000 or 500?<br />
** Let's create "variables" :<br />
*** const int period_flash_short = 200;<br />
*** const int period_flash_long = 1000;<br />
** We can use these everywhere as required, and then play with the values more easily.<br />
<br />
===== Answer to 2.1 with copy paste =====<br />
void setup() {<br />
pinMode(13, OUTPUT);<br />
}<br />
void loop() {<br />
/* display 's' : three short flashes */<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
<br />
/* display 'o' : three long flashes */<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(1000); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(1000); // wait for a second<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(1000); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(1000); // wait for a second<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(1000); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(1000); // wait for a second<br />
<br />
/* display 's' : three short flashes */<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
}<br />
<br />
===== Answer to 2.1 with functions and parameters =====<br />
const int period_flash_short = 200;<br />
const int period_flash_long = 1000;<br />
<br />
/* short flash: period_flash_short ms on, period_flash_short ms off */<br />
int short_flash(void) {<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(period_flash_short); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(period_flash_short); // wait for 200ms<br />
}<br />
/* short flash: 1s on, 1s off */<br />
int long_flash(void) {<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(period_flash_long); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(period_flash_long); // wait for a second<br />
}<br />
/* display 's' : three short flashes */<br />
void display_S(void) {<br />
short_flash();<br />
short_flash();<br />
short_flash();<br />
}<br />
/* display 'o' : three long flashes */<br />
void display_O(void) {<br />
long_flash();<br />
long_flash();<br />
long_flash();<br />
}<br />
<br />
void setup() {<br />
pinMode(13, OUTPUT);<br />
}<br />
void loop() {<br />
display_S();<br />
display_O();<br />
display_S();<br />
}<br />
<br />
<br />
===== Bonus Question 2.2 =====<br />
How can we change the morse code displaying speed?<br />
<br />
===== Answers to 2.2 =====<br />
Another obvious reason why parameterized code is better than "hardcoded" values.<br />
const int period_flash_base = 200;<br />
const int period_flash_short = 1;<br />
const int period_flash_long = 5;<br />
<br />
/* short flash: period_flash_short ms on, period_flash_short ms off */<br />
int short_flash(void) {<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(period_flash_short*period_flash_base); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(period_flash_short*period_flash_base); // wait for 200ms<br />
}<br />
/* short flash: 1s on, 1s off */<br />
int long_flash(void) {<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(period_flash_long*period_flash_base); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(period_flash_long*period_flash_base); // wait for a second<br />
}<br />
/* display 's' : three short flashes */<br />
void display_S(void) {<br />
short_flash();<br />
short_flash();<br />
short_flash();<br />
}<br />
/* display 'o' : three long flashes */<br />
void display_O(void) {<br />
long_flash();<br />
long_flash();<br />
long_flash();<br />
}<br />
<br />
void setup() {<br />
pinMode(13, OUTPUT);<br />
}<br />
void loop() {<br />
display_S();<br />
display_O();<br />
display_S();<br />
}<br />
<br />
<br />
===== Bonus Question 2.3 =====<br />
How to change the message sent?<br />
<br />
===== Answers to 2.3 =====<br />
We could create a function that takes a character as argument, eg "display_morse(char c)" or similar<br />
void display_morse(char c) {<br />
swithc(c) {<br />
case 's':<br />
short_flash();<br />
short_flash();<br />
short_flash();<br />
break;<br />
<br />
case 'o':<br />
long_flash();<br />
long_flash();<br />
long_flash();<br />
break;<br />
<br />
default:<br />
break;<br />
}<br />
}<br />
<br />
=== Variable intensity with a LED ===<br />
<br />
==== Challenge 3: ultra fast blinking ====<br />
Question: what happens when you blink a led suuuuper fast?<br />
<br />
Once again: you can think about it... or directly try it out! Change the value in delay, eg first try ''delay(100)'', then maybe ''delay(10)'', and why not ''delay(1)''<br />
<br />
Answer: because of [https://en.wikipedia.org/wiki/Persistence_of_vision persistence of vision], one can't distinguish each flash when they happen too fast, and instead we see an average intensity.<br />
<br />
Question: find out which blinking speed is the limit above which one cannot see each flash.<br />
<br />
Answer: with delay values 10 and 10, eg approximately 50Hz (50 blink a second), it is hard to see each blink. They are impossible to count, at least!<br />
<br />
Question: what does it even mean, suuuuper fast, for the microcontroller?<br />
<br />
Answer: the central reference clock (that is kind of a metronome) for the central processor unit is at the frequency of 16MHz. Each second, the central CPU gets 16.000.000 ticks, and performs a basic action. Much lower than a modern PC or smartphone (100 times faster, at aroung 2GHz, or 2.000.000.000 ticks per second)... but blinking 50 times a second is fast for a human eye, but not really for a microcontroller.<br />
<br />
<br />
==== Challenge 4: let's play with delay values ====<br />
Question: what happens when we use different delay values for time on and time off?<br />
<br />
Let's try it! For example:<br />
* on, delay(200), off, delay(800), and then the opposite: on, delay(800), off, delay(200).<br />
* opposite: on, delay(800), off, delay(200).<br />
* faster: on, delay(8), off, delay(2).<br />
* faster: on, delay(2), off, delay(8).<br />
* etc: on, delay(4), off, delay(6).<br />
<br />
<br />
Answer: what we're doing here is called [https://en.wikipedia.org/wiki/Pulse-width_modulation pulse width modulation]. The '''frequency''' (eg how many time per second there is a blink) is something different than the '''duty cycle''' (eg % of time the led is ON versus time it is off, on average).<br />
<br />
<br />
With an output just capable of doing "on" and "off", we can manage to do an output that varies between 0% and 100%! The microcontroller and Arduino have a dedicated function to do this for us: see the example Analog/fade.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:Initiation:EnFormations:Arduino:Initiation:En2016-10-04T14:51:51Z<p>Clément: /* Allumer des LED avec intensité variable */</p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Introduction to microcontrollers with the Arduino platform =<br />
Arduino, the famous microcontroler board, makes it easy to hack embedded systems that involves sensors, actuators, programs.<br />
In this workshop, we'll discover what it can do: input, output, communication.<br />
To do so, we'll play with several challenges that an Arduino can easily solve.<br />
<br />
This workshop is open to everyone, and is intended as an help for your first steps in the Arduino world.<br />
<br />
<br />
== Info ==<br />
* Duration: 3h or more<br />
* Target audience: any Electrolab member, beginner level in computer programming/electronics/Arduino<br />
<br />
== Related trainings ==<br />
* prerequisite: nothing special, except ability to read & basic computer skills<br />
* Ideally:<br />
** basic notions of electronics : see corresponding [[Formations:Electronique:Initiation:En|training on this topic]]<br />
** basic notions of (computer) programming : see corresponding [[Formations:Programmation:Initiation:En|training on this topic]]<br />
<br />
* Following trainings:<br />
** My First Arduino Project<br />
<br />
== Equipment ==<br />
It is mandatory to bring your own laptop. You must install the Arduino software before the training. Please refer to https://www.arduino.cc/en/Main/Software<br />
<br />
Examples and exercices on this page use content from the Arduino starterkit, Electrolab version.<br />
This kit is sold 30€, and several kits are also available during the training<br />
<br />
Contents :<br />
* Arduino Nano + USB cable<br />
* breadboard (400p) and cables male/male et female/female<br />
* potentiometer and pushbutton (joystick)<br />
* leds: red, green, yellow, white, blue, RGB and resistor (x8) 330 ohm<br />
* photoresistor & thermistor + adapted resistor set (2x1k, 2x10k, 2x100k)<br />
* micro-servomotor, buzzer<br />
<br />
Warning: the Arduino nano board that we use require a special device driver ! These are dirtycheap clones made in China.<br />
<br />
=== IDE (software) installation ===<br />
(maybe move this section some place else?)<br />
* see https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide<br />
* please note that our boards require the ch340 device driver, that does not come with the IDE installation.<br />
See https://www.google.com/?q=ch340+driver to install the mandatory specific device driver without which our kits wont work<br />
<br />
== Additionnal info ==<br />
To buy equipment:<br />
* the Electrolab sells a few components & modules, additionnaly to the starterkit<br />
* many many shops sell Arduino stuff: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== About Arduino ===<br />
* On their website www.arduino.cc : [https://www.arduino.cc/en/Tutorial/HomePage tutorials] and also [https://www.arduino.cc/en/Tutorial/BuiltInExamples code examples with explanations] <br />
* [https://www.arduino.cc/en/Guide/HomePage a similar page to the one you're reading now], directly on the official website (not as good, of course ;)<br />
* [http://eduscol.education.fr/sti/sites/eduscol.education.fr.sti/files/ressources/techniques/3846/3846-les-cles-de-la-carte-esplora.pdf nice document about the esplora board]<br />
* French speaking reference website: http://eskimon.fr/<br />
* Check out website of shops: Sparkfun, Adafruit Industries, ... have lots of online ressource<br />
* deadtree book: I personnally find "Arduino for dummies" interesting.<br />
<br />
=== About programming ===<br />
* basic notions of computer programming : see our [[Formations:Programmation:Initiation:En|training on this topic]]<br />
* see [https://www.arduino.cc/en/Reference/HomePage this page for Arduino language & reference]<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_g%C3%A9n%C3%A9rale_%C3%A0_la_programmation and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_au_langage_C and similar english page.<br />
<br />
=== About electronics ===<br />
* basic notions of electronics: see our [[Formations:Electronique:Initiation:En|training on this topic]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|on our wiki]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectromagn%C3%A9tisme_et_%C3%A9lectricit%C3%A9 and similar english page.<br />
<br />
= Content of the training =<br />
This is designed to be a training at the Electrolab.<br />
One can probably follow along without coming to the actual training on site... but this page needs more work before this is a good option.<br />
Slides from the training will be published here later on.<br />
<br />
== Introduction ==<br />
This training intends to help you discover microcontrollers and how to use them, by using the Arduino platform.<br />
No special knowledge is required for this training: we'll see along everything we need. Of course, if you want to know more on the topic of electronics and computer programming, you should check out our trainings on these topics.<br />
<br />
Let's see what microcontrolers are, how to use them. This will open the gates to a vast diversity of projects !<br />
<br />
==== Preliminary: notions of electronics and computer programming ====<br />
In this training we'll use:<br />
* elecronics related concepts:<br />
** electricity, voltage/current<br />
** electronic circuit, schematic & component model<br />
* computer programming related concepts:<br />
** what is a computer program? a programming language? How to use this?<br />
** C language semantics and [https://www.arduino.cc/en/Reference/HomePage Arduino specific keywords].<br />
** workflow associated with computer programming: design, writing your program, compiling, testing & bug tracking, ...<br />
We have trainings on these topics.<br />
<br />
In any case, no need to be an expert to follow along the Arduino training: do not hesitate to ask questions along the way, including (most encouraged) to your neighbours.<br />
<br />
=== Microcontrollers ===<br />
To learn more, here's the manufacturer webpage of the central chip that we will use: http://www.atmel.com/devices/atmega328p.aspx<br />
<br />
The main technical reference document is its datasheet. This is a long but very interesting read, that you should at least check out quickly: http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf<br />
<br />
There are course material pages on there: https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR<br />
<br />
<br />
==== What is a microcontroller? ====<br />
A microcontroller is a type of chip that is widespread. It can be seen as a small computer that is all integrated on one silicon chip: processor (CPU), memory (RAM & flash), various input/output managers, various peripherals, ... all in one single tiny chip.<br />
This thing is thus capable of interacting closely with the real world: measure physical values with various sensors, and act upon the world by driving actuators. Inbetween sensing and actuating (input and output), the central processor makes "decisions": it executes the program that has been written by you or someone else, and thus follows strictly the behavior that has been described.<br />
<br />
This is a powerful thing: by just writing a different program, you can completely change the behavior of the system. It is also super flexible, because your program can be arbitrarily complex, and give an also arbitrarily complex behavior to the system.<br />
<br />
TODO: picture of the chip on the board: systemic view, with inputs, arrows, CPU+software, arrows, outputs<br />
<br />
==== What is a microprocessor? ====<br />
We also use the acronym: CPU, central processing unit. That's the thing at the heart of a computer, that executes the instructions corresponding to a program. These instructions are very simple:<br />
* add the value 42 to the memory location #3<br />
* if memory location #3 is zero, go execute instruction two locations lower in program memory.<br />
* otherwise, execute the one one location lower in program memory.<br />
<br />
It is not easy to give computers instructions at such a low level of absstraction (eg, assembly leve), because one has to know exactly what the CPU at hand can or cannot do, and how. Most importantly, it is impossible to give complex orders (with a high level of abstraction), like "display an image" or "compute the average value of a group of values". The natural tendency is to use programming language with more and more evolved, abstract, complex instructions (high level languages), that make the programmer's job easier.<br />
<br />
<br />
Physical implementation of a CPU is a fascinating topic: it's where the fronteer between hardware and software is blurry, and where the magic happens : let's keep it for the "introduction to digital electronics" training...<br />
<br />
==== What is binary and number of bits? ====<br />
CPU can handle only 0 and 1: these a digital circuits. To manipulate "real" number, we use base 2, which considers 1 and 0 as digits to represent any number. For example, the number 6 that you well know (formally, can be written as 6*10^0), can also be written as 2+4, or, with base 2: 1*2^2 + 1*2^1 + 0*2^0, or again 110 (base two). These digits that can be 0 or 1 are called bits, or binary digits.<br />
<br />
One major parameter of CPU design is the size of numbers it can natively handle: it depends on how many digits (bits) it can handle at once for a given number. For example, the microcontroler we use in these Arduino has an 8bits CPU: internally, it uses 8 digits numbers, each digit being either 0 or 1.<br />
<br />
So, that should mean the largest number it can handle is 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. Quite small!<br />
<br />
You may ask: what's up with negative numbers, decimal (eg 1.27) numbers, etc... there are ways to do this, but it isnt easy for a small CPU like the one in the Arduino's microcontroller.<br />
<br />
<br />
See:<br />
* https://fr.wikiversity.org/wiki/Code_de_num%C3%A9ration/Introduction or similar in english<br />
* https://fr.wikipedia.org/wiki/Virgule_fixe fixed point.<br />
* https://fr.wikipedia.org/wiki/IEEE_754 (floating point number representation: warning, this isnt an easy topic)<br />
<br />
==== What are they useful for? Where? ====<br />
Many things: interface sensors & actuators of any kind, and decide behavior through writing a programm makes it possible to create sooo many cool things. For example, a washing machine, a modern car, an elevator, ... many, most if not all everyday objects rely on a microcontroller to function as expected. It could be seen as the brain ot said object.<br />
<br />
TODO: picture of a simple system: input, output, software, for an everyday object.<br />
<br />
For example {any closed loop system, or finite state machine based system, that audience can relate to: washing machine, elevator, ...?)<br />
<br />
<br />
==== How to use it? ====<br />
* system design: first, think and make explicit what it is that you're trying to do. What input will you use, and how? Which outputs do you expect, and when? What is the overal expected behavior? What are the missions/goals?<br />
* hardware design: once this is all clear, design & create the hardware, create the schematic with selected sensors & actuators. It may make sense to separate clearly different modules, and perform hierarchical design: first learn how to get values from this sensor, then, tackle all issues specifically related to that motor, before trying to do everything at once.<br />
* software design: once your hardware is ready, you can work on software: here again, it probably makes sense to start with separate modules: divide to conquer applies here. Try out bits of software, think about your overall design before writing code.<br />
* Tests, bug tracking & modifications to the design: nothing ever works the first time...<br />
<br />
=== The Arduino platform & world ===<br />
Arduino has been design for students in design and artists, which means non specialists in electronics, computer science and embedded systems, to allow them to design and hack things that require a microcontroller. This means that "easy to get started with" is at the first position in the requirement list for Arduino. As we shall soon see, this is quite a success!<br />
<br />
Teaching support: create a tool that is easy to use and allows student to do stuff. Wiring is almost as important as Arduino (boards). Is based on free software, and is itself free, too (as in free speech, not free beer: you still have to buy the boards)<br />
<br />
==== What is Arduino ? ====<br />
Compared to the many boards & platforms that existed before Arduino, several aspects make it 100% more awesome:<br />
* Opensource: it relies on existing opensource projects, and everything that has been added is also published under free licenses. This has the usual advantages of free software.<br />
* Cheap: by design, the board had to cost not more than one meal. Being affordable allows people to actually get one and play with it without the fear to destroy it. It began at around 20€ per board, which was 5x cheaper than similar platforms. Now, dirtycheap clones cost few € each.<br />
* Not a toy or just a teaching contraption: they designed an easy to use and intuitive interface, shortcuts in the programming language, and a robust electronic board. BUT all this relies on "real" tools that professionnals use everyday, making them easier to use. This allows anyone to check what's under the hood after the first few steps, and get your hands dirty if you need or want to.<br />
<br />
All this worked well beyond initial plans, and a growing number of people started using Arduino, contribution upgrades, documenting projects, additionnal modules and features... today, the community is extremely active and powerful. There are an incredible number of sensors, actuators, code and project example out there for anyone to learn from and use in whatever project they like, making a wide range of project much, much easier to achieve.<br />
<br />
==== Anatomy of an Arduino electronic board ====<br />
Arduino nano board: picture, feature sheet, etc...<br />
<br />
In this training, we'll use an all integrated board: the Arduino Nano<br />
<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg picture of a Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png pinout of a Arduino Nano]<br />
<br />
==== Features of our Arduino board ====<br />
Added to the CPU (that executes the software that we write) and the memory (flash, to store the data even when the power is out, and RAM for the value we're working on), the microcontroler on the Arduino board knows various different tricks:<br />
* A bit more than ten inputs that we call "digital": the mcu can "see" the presence or absence of a voltage, at defined levels. Our program is able to read the value of the voltage on a pin that is configured as an input, and we can use the value read in our program. We use the term "high" and "low" level, for a voltage of 0v or 5v between that pin and the GND pin of the microcontroller.<br />
* These pins can also be configured as outputs: here, it is the CPU (and thus, our program) that forces the voltage level, either high (5v) or low (0v). Warning: there is a power limit on what each pin and the whole mcu can provide! Each pin can source (eg, it flows out of the chip) or sink (eg it flows in the chip) 20mA, not more. It is the power level required to light an average LED... moving an electric bike may require 1000 times more power: the mcu cannot do this without additionnal circuitry.<br />
* Analog voltage inputs (between 0v and 5v): the mcu we use has a very useful peripheral: an Analog Digital Converter. It can convert an analog voltage (here, between 0 and 5v) present on a specific input pin (6 of them on our board) into a value between 0 and 1023. Why this range? It uses 10 bits numbers. So for exemple, if there is a voltage of 2.5v on an analog input pin, the ADC will read a value of 512 (1023*2.5v/5v = 512).<br />
* For various reasons, there is no easy way to generate an output other than 0v or 5v... dont worry, we'll see how to achieve this with different tricks later !<br />
<br />
The mcu we use also contains all the required hardware to communicate with a computer. It also has lots of other peripherals and things more sophisticated, that can be learnt about later. Please read the datasheet, that is an exhaustive source of information on the chip's features.<br />
<br />
Note: it has enough RAM (to store variables) and flash memory (to store our program) for most of the applications we can work on.<br />
<br />
==== Use the software tool ====<br />
We use the Arduino IDE to write our program, compile (eg transform from human readable to machine usable) it and transfer it to the Arduino board memory through the USB connexion.<br />
<br />
<br />
* menus: chose board & port, access the example projects<br />
* buttons: upload, launch terminal/serial monitor<br />
* <br />
TODO: lots of pictures<br />
<br />
==== Software install ====<br />
'''Installation/verification of the IDE and driver.'''<br />
Note: this should be on anoter page..? just refer to the official page?<br />
<br />
TODO: pictures de partout.<br />
<br />
* howto install IDE : see official website<br />
* howto install driver: harder, as it seems that no website is stable enough as a reference...<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== What's in the starterkit? ===<br />
Let's check out the Arduino Starterkit contents.<br />
<br />
TODO: lots of pictures ; maybe link to other pages instead (eg doc of the kit)<br />
<br />
*Breadboard <br />
** describe how it works<br />
** explain how to create a circuit<br />
* component X: TODO<br />
<br />
== Outputs==<br />
Let's get our hands dirty with the output capabilities of the Arduino.<br />
The first example ever is to play with a LED.<br />
<br />
=== Turn on and off a LED ===<br />
<br />
==== "blink" example and basic functions ====<br />
Our first program is named "Blink", it blinks a LED. It is an example program provided by the Arduino IDE. It can be found in File/Example/Basics.<br />
<br />
Once you've opened this project, clic on the "upload" button to compile the code, and transfer the resulting binary into the mcu flash memory. As a result, the LED called "L", that is connected to pin 13 on an Arduino, blinks at a steady pace.<br />
<br />
This rather simple test is the traditionnal first step with any new mcu platform: congratulations, you've just made your first step with an Arduino :)<br />
<br />
<br />
'''Wiring:'''<br />
There is no need to do any type of wiring: everything that is required is already on the Arduino board we use!<br />
<br />
TODO: pictures.<br />
<br />
'''Understanding the schematic:'''<br />
The schematic is very simple: a LED is connected to the D13 pin of the mcu. There is a resistor in serie, to limit the current to an acceptable value. The LED is correctly oriented so that there is current flowing through it when the pin D13 is set at 'HIGH'.<br />
<br />
One can check [https://www.arduino.cc/en/uploads/Main/ArduinoNano30Schematic.pdf the Nano board schematic] to understand, check components values, etc. For example, the resistor is 330 ohm, one can guess that the LED has a threshold value of 2v, so when there's a HIGH value on D13 (eg 5v), there is 3v across the resistor, so a current flowing through it of 3/330 A, which is approximately 10mA: that's alright for a LED that can probably withtand currents up to 50mA, and the mcu that can do 20mA.<br />
<br />
TODO: picture schematic arduino output 13 +resistor + LED, current & voltage.<br />
<br />
'''Source code:'''<br />
Let's check the source code:<br />
* setup() is a function (bloc of instructions) that gets executed when the board powers up. It is useful to do all the setup that we need for our project. Here: explicit that pin 13 shall be an output (output: the MCU drives the state of that pin)<br />
* loop() is a funciton (bloc of instructions) that gets repetedly executed - as a loop. It contains four lines:<br />
** we turn the LED on by driving the pin D13 to HIGH<br />
** we wait for 1000 milliseconds, which is one second<br />
** we turn the LED off by driving the pin D13 to LOW<br />
** we wait for 1000 milliseconds, which is one second<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Challenge 1: change blinking speed ====<br />
Question: how can we change the speed at which the LED blinks?<br />
<br />
Not a theory question: try to change the code to have the LED blink at a different speed, and clic the upload button to check if your modification achieves your goal.<br />
<br />
Answer: {TODO: shall be hidden/spoiler protected!}<br />
* by changing the value 1000, we change the wait time after we turn the LED on and off. For example:<br />
** with the values 200 and 200, the LED blinks 5 times faster<br />
** with the values 2000 and 2000, the LED blinks 2 times slower<br />
** with 500 and 1500, the LED blinks at the same speed, but it is turned on for less long<br />
<br />
Result:<br />
* Understanding of a simple program<br />
* we've immediately done something real with that LED!<br />
<br />
==== Challenge 2: SOS in morse code ====<br />
Question: how can we create more complex blinking patterns? For example, let's do the famous "SOS" in morse code: ...---... which is three short flashes (code for 'S'), three long (code for 'O') and again three short flashes.<br />
<br />
Let's display this on the L LED!<br />
<br />
Remember: even on a simple example, a well structured and cleaned up program is much better.<br />
<br />
<br />
===== Answers to 2.1 =====<br />
* there are several different ways of achieving this:<br />
** copy paste the four lines of code we already know as many times as required, with changed values for the delay() function<br />
** create our own functions, like "short_flash()" and "long_flash()", or display_S() and display_O()<br />
* use parameterized code makes sense:<br />
** having "magic numbers" everywhere we use delay() is problematic: it isnt easy to change these values, and when reading the code, who knows why the value is 1000 or 500?<br />
** Let's create "variables" :<br />
*** const int period_flash_short = 200;<br />
*** const int period_flash_long = 1000;<br />
** We can use these everywhere as required, and then play with the values more easily.<br />
<br />
===== Answer to 2.1 with copy paste =====<br />
void setup() {<br />
pinMode(13, OUTPUT);<br />
}<br />
void loop() {<br />
/* display 's' : three short flashes */<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
<br />
/* display 'o' : three long flashes */<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(1000); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(1000); // wait for a second<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(1000); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(1000); // wait for a second<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(1000); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(1000); // wait for a second<br />
<br />
/* display 's' : three short flashes */<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
}<br />
<br />
===== Answer to 2.1 with functions and parameters =====<br />
const int period_flash_short = 200;<br />
const int period_flash_long = 1000;<br />
<br />
/* short flash: period_flash_short ms on, period_flash_short ms off */<br />
int short_flash(void) {<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(period_flash_short); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(period_flash_short); // wait for 200ms<br />
}<br />
/* short flash: 1s on, 1s off */<br />
int long_flash(void) {<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(period_flash_long); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(period_flash_long); // wait for a second<br />
}<br />
/* display 's' : three short flashes */<br />
void display_S(void) {<br />
short_flash();<br />
short_flash();<br />
short_flash();<br />
}<br />
/* display 'o' : three long flashes */<br />
void display_O(void) {<br />
long_flash();<br />
long_flash();<br />
long_flash();<br />
}<br />
<br />
void setup() {<br />
pinMode(13, OUTPUT);<br />
}<br />
void loop() {<br />
display_S();<br />
display_O();<br />
display_S();<br />
}<br />
<br />
<br />
===== Bonus Question 2.2 =====<br />
How can we change the morse code displaying speed?<br />
<br />
===== Answers to 2.2 =====<br />
Another obvious reason why parameterized code is better than "hardcoded" values.<br />
const int period_flash_base = 200;<br />
const int period_flash_short = 1;<br />
const int period_flash_long = 5;<br />
<br />
/* short flash: period_flash_short ms on, period_flash_short ms off */<br />
int short_flash(void) {<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(period_flash_short*period_flash_base); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(period_flash_short*period_flash_base); // wait for 200ms<br />
}<br />
/* short flash: 1s on, 1s off */<br />
int long_flash(void) {<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(period_flash_long*period_flash_base); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(period_flash_long*period_flash_base); // wait for a second<br />
}<br />
/* display 's' : three short flashes */<br />
void display_S(void) {<br />
short_flash();<br />
short_flash();<br />
short_flash();<br />
}<br />
/* display 'o' : three long flashes */<br />
void display_O(void) {<br />
long_flash();<br />
long_flash();<br />
long_flash();<br />
}<br />
<br />
void setup() {<br />
pinMode(13, OUTPUT);<br />
}<br />
void loop() {<br />
display_S();<br />
display_O();<br />
display_S();<br />
}<br />
<br />
<br />
===== Bonus Question 2.3 =====<br />
How to change the message sent?<br />
<br />
===== Answers to 2.3 =====<br />
We could create a function that takes a character as argument, eg "display_morse(char c)" or similar<br />
void display_morse(char c) {<br />
swithc(c) {<br />
case 's':<br />
short_flash();<br />
short_flash();<br />
short_flash();<br />
break;<br />
<br />
case 'o':<br />
long_flash();<br />
long_flash();<br />
long_flash();<br />
break;<br />
<br />
default:<br />
break;<br />
}<br />
}<br />
<br />
=== Variable intensity with a LED ===<br />
<br />
==== Challenge 3: ultra fast blinking ====<br />
Question: what happens when you blink a led suuuuper fast?<br />
<br />
Once again: you can think about it... or directly try it out! Change the value in delay, eg first try ''delay(100)'', then maybe ''delay(10)'', and why not ''delay(1)''<br />
<br />
Answer: because of [https://en.wikipedia.org/wiki/Persistence_of_vision persistence of vision], one can't distinguish each flash when they happen too fast, and instead we see an average intensity.<br />
<br />
Question: find out which blinking speed is the limit above which one cannot see each flash.<br />
<br />
Answer: with delay values 10 and 10, eg approximately 50Hz (50 blink a second), it is hard to see each blink. They are impossible to count, at least!<br />
<br />
Question: what does it even mean, suuuuper fast, for the microcontroller?<br />
<br />
Answer: the central reference clock (that is kind of a metronome) for the central processor unit is at the frequency of 16MHz. Each second, the central CPU gets 16.000.000 ticks, and performs a basic action. Much lower than a modern PC or smartphone (100 times faster, at aroung 2GHz, or 2.000.000.000 ticks per second)... but blinking 50 times a second is fast for a human eye, but not really for a microcontroller.<br />
<br />
<br />
==== Défi 4 : jouer avec les délais ====<br />
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:Initiation:EnFormations:Arduino:Initiation:En2016-09-29T12:07:16Z<p>Clément: /* Défi 2: SOS morse */</p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Introduction to microcontrollers with the Arduino platform =<br />
Arduino, the famous microcontroler board, makes it easy to hack embedded systems that involves sensors, actuators, programs.<br />
In this workshop, we'll discover what it can do: input, output, communication.<br />
To do so, we'll play with several challenges that an Arduino can easily solve.<br />
<br />
This workshop is open to everyone, and is intended as an help for your first steps in the Arduino world.<br />
<br />
<br />
== Info ==<br />
* Duration: 3h or more<br />
* Target audience: any Electrolab member, beginner level in computer programming/electronics/Arduino<br />
<br />
== Related trainings ==<br />
* prerequisite: nothing special, except ability to read & basic computer skills<br />
* Ideally:<br />
** basic notions of electronics : see corresponding [[Formations:Electronique:Initiation:En|training on this topic]]<br />
** basic notions of (computer) programming : see corresponding [[Formations:Programmation:Initiation:En|training on this topic]]<br />
<br />
* Following trainings:<br />
** My First Arduino Project<br />
<br />
== Equipment ==<br />
It is mandatory to bring your own laptop. You must install the Arduino software before the training. Please refer to https://www.arduino.cc/en/Main/Software<br />
<br />
Examples and exercices on this page use content from the Arduino starterkit, Electrolab version.<br />
This kit is sold 30€, and several kits are also available during the training<br />
<br />
Contents :<br />
* Arduino Nano + USB cable<br />
* breadboard (400p) and cables male/male et female/female<br />
* potentiometer and pushbutton (joystick)<br />
* leds: red, green, yellow, white, blue, RGB and resistor (x8) 330 ohm<br />
* photoresistor & thermistor + adapted resistor set (2x1k, 2x10k, 2x100k)<br />
* micro-servomotor, buzzer<br />
<br />
Warning: the Arduino nano board that we use require a special device driver ! These are dirtycheap clones made in China.<br />
<br />
=== IDE (software) installation ===<br />
(maybe move this section some place else?)<br />
* see https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide<br />
* please note that our boards require the ch340 device driver, that does not come with the IDE installation.<br />
See https://www.google.com/?q=ch340+driver to install the mandatory specific device driver without which our kits wont work<br />
<br />
== Additionnal info ==<br />
To buy equipment:<br />
* the Electrolab sells a few components & modules, additionnaly to the starterkit<br />
* many many shops sell Arduino stuff: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== About Arduino ===<br />
* On their website www.arduino.cc : [https://www.arduino.cc/en/Tutorial/HomePage tutorials] and also [https://www.arduino.cc/en/Tutorial/BuiltInExamples code examples with explanations] <br />
* [https://www.arduino.cc/en/Guide/HomePage a similar page to the one you're reading now], directly on the official website (not as good, of course ;)<br />
* [http://eduscol.education.fr/sti/sites/eduscol.education.fr.sti/files/ressources/techniques/3846/3846-les-cles-de-la-carte-esplora.pdf nice document about the esplora board]<br />
* French speaking reference website: http://eskimon.fr/<br />
* Check out website of shops: Sparkfun, Adafruit Industries, ... have lots of online ressource<br />
* deadtree book: I personnally find "Arduino for dummies" interesting.<br />
<br />
=== About programming ===<br />
* basic notions of computer programming : see our [[Formations:Programmation:Initiation:En|training on this topic]]<br />
* see [https://www.arduino.cc/en/Reference/HomePage this page for Arduino language & reference]<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_g%C3%A9n%C3%A9rale_%C3%A0_la_programmation and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_au_langage_C and similar english page.<br />
<br />
=== About electronics ===<br />
* basic notions of electronics: see our [[Formations:Electronique:Initiation:En|training on this topic]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|on our wiki]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectromagn%C3%A9tisme_et_%C3%A9lectricit%C3%A9 and similar english page.<br />
<br />
= Content of the training =<br />
This is designed to be a training at the Electrolab.<br />
One can probably follow along without coming to the actual training on site... but this page needs more work before this is a good option.<br />
Slides from the training will be published here later on.<br />
<br />
== Introduction ==<br />
This training intends to help you discover microcontrollers and how to use them, by using the Arduino platform.<br />
No special knowledge is required for this training: we'll see along everything we need. Of course, if you want to know more on the topic of electronics and computer programming, you should check out our trainings on these topics.<br />
<br />
Let's see what microcontrolers are, how to use them. This will open the gates to a vast diversity of projects !<br />
<br />
==== Preliminary: notions of electronics and computer programming ====<br />
In this training we'll use:<br />
* elecronics related concepts:<br />
** electricity, voltage/current<br />
** electronic circuit, schematic & component model<br />
* computer programming related concepts:<br />
** what is a computer program? a programming language? How to use this?<br />
** C language semantics and [https://www.arduino.cc/en/Reference/HomePage Arduino specific keywords].<br />
** workflow associated with computer programming: design, writing your program, compiling, testing & bug tracking, ...<br />
We have trainings on these topics.<br />
<br />
In any case, no need to be an expert to follow along the Arduino training: do not hesitate to ask questions along the way, including (most encouraged) to your neighbours.<br />
<br />
=== Microcontrollers ===<br />
To learn more, here's the manufacturer webpage of the central chip that we will use: http://www.atmel.com/devices/atmega328p.aspx<br />
<br />
The main technical reference document is its datasheet. This is a long but very interesting read, that you should at least check out quickly: http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf<br />
<br />
There are course material pages on there: https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR<br />
<br />
<br />
==== What is a microcontroller? ====<br />
A microcontroller is a type of chip that is widespread. It can be seen as a small computer that is all integrated on one silicon chip: processor (CPU), memory (RAM & flash), various input/output managers, various peripherals, ... all in one single tiny chip.<br />
This thing is thus capable of interacting closely with the real world: measure physical values with various sensors, and act upon the world by driving actuators. Inbetween sensing and actuating (input and output), the central processor makes "decisions": it executes the program that has been written by you or someone else, and thus follows strictly the behavior that has been described.<br />
<br />
This is a powerful thing: by just writing a different program, you can completely change the behavior of the system. It is also super flexible, because your program can be arbitrarily complex, and give an also arbitrarily complex behavior to the system.<br />
<br />
TODO: picture of the chip on the board: systemic view, with inputs, arrows, CPU+software, arrows, outputs<br />
<br />
==== What is a microprocessor? ====<br />
We also use the acronym: CPU, central processing unit. That's the thing at the heart of a computer, that executes the instructions corresponding to a program. These instructions are very simple:<br />
* add the value 42 to the memory location #3<br />
* if memory location #3 is zero, go execute instruction two locations lower in program memory.<br />
* otherwise, execute the one one location lower in program memory.<br />
<br />
It is not easy to give computers instructions at such a low level of absstraction (eg, assembly leve), because one has to know exactly what the CPU at hand can or cannot do, and how. Most importantly, it is impossible to give complex orders (with a high level of abstraction), like "display an image" or "compute the average value of a group of values". The natural tendency is to use programming language with more and more evolved, abstract, complex instructions (high level languages), that make the programmer's job easier.<br />
<br />
<br />
Physical implementation of a CPU is a fascinating topic: it's where the fronteer between hardware and software is blurry, and where the magic happens : let's keep it for the "introduction to digital electronics" training...<br />
<br />
==== What is binary and number of bits? ====<br />
CPU can handle only 0 and 1: these a digital circuits. To manipulate "real" number, we use base 2, which considers 1 and 0 as digits to represent any number. For example, the number 6 that you well know (formally, can be written as 6*10^0), can also be written as 2+4, or, with base 2: 1*2^2 + 1*2^1 + 0*2^0, or again 110 (base two). These digits that can be 0 or 1 are called bits, or binary digits.<br />
<br />
One major parameter of CPU design is the size of numbers it can natively handle: it depends on how many digits (bits) it can handle at once for a given number. For example, the microcontroler we use in these Arduino has an 8bits CPU: internally, it uses 8 digits numbers, each digit being either 0 or 1.<br />
<br />
So, that should mean the largest number it can handle is 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. Quite small!<br />
<br />
You may ask: what's up with negative numbers, decimal (eg 1.27) numbers, etc... there are ways to do this, but it isnt easy for a small CPU like the one in the Arduino's microcontroller.<br />
<br />
<br />
See:<br />
* https://fr.wikiversity.org/wiki/Code_de_num%C3%A9ration/Introduction or similar in english<br />
* https://fr.wikipedia.org/wiki/Virgule_fixe fixed point.<br />
* https://fr.wikipedia.org/wiki/IEEE_754 (floating point number representation: warning, this isnt an easy topic)<br />
<br />
==== What are they useful for? Where? ====<br />
Many things: interface sensors & actuators of any kind, and decide behavior through writing a programm makes it possible to create sooo many cool things. For example, a washing machine, a modern car, an elevator, ... many, most if not all everyday objects rely on a microcontroller to function as expected. It could be seen as the brain ot said object.<br />
<br />
TODO: picture of a simple system: input, output, software, for an everyday object.<br />
<br />
For example {any closed loop system, or finite state machine based system, that audience can relate to: washing machine, elevator, ...?)<br />
<br />
<br />
==== How to use it? ====<br />
* system design: first, think and make explicit what it is that you're trying to do. What input will you use, and how? Which outputs do you expect, and when? What is the overal expected behavior? What are the missions/goals?<br />
* hardware design: once this is all clear, design & create the hardware, create the schematic with selected sensors & actuators. It may make sense to separate clearly different modules, and perform hierarchical design: first learn how to get values from this sensor, then, tackle all issues specifically related to that motor, before trying to do everything at once.<br />
* software design: once your hardware is ready, you can work on software: here again, it probably makes sense to start with separate modules: divide to conquer applies here. Try out bits of software, think about your overall design before writing code.<br />
* Tests, bug tracking & modifications to the design: nothing ever works the first time...<br />
<br />
=== The Arduino platform & world ===<br />
Arduino has been design for students in design and artists, which means non specialists in electronics, computer science and embedded systems, to allow them to design and hack things that require a microcontroller. This means that "easy to get started with" is at the first position in the requirement list for Arduino. As we shall soon see, this is quite a success!<br />
<br />
Teaching support: create a tool that is easy to use and allows student to do stuff. Wiring is almost as important as Arduino (boards). Is based on free software, and is itself free, too (as in free speech, not free beer: you still have to buy the boards)<br />
<br />
==== What is Arduino ? ====<br />
Compared to the many boards & platforms that existed before Arduino, several aspects make it 100% more awesome:<br />
* Opensource: it relies on existing opensource projects, and everything that has been added is also published under free licenses. This has the usual advantages of free software.<br />
* Cheap: by design, the board had to cost not more than one meal. Being affordable allows people to actually get one and play with it without the fear to destroy it. It began at around 20€ per board, which was 5x cheaper than similar platforms. Now, dirtycheap clones cost few € each.<br />
* Not a toy or just a teaching contraption: they designed an easy to use and intuitive interface, shortcuts in the programming language, and a robust electronic board. BUT all this relies on "real" tools that professionnals use everyday, making them easier to use. This allows anyone to check what's under the hood after the first few steps, and get your hands dirty if you need or want to.<br />
<br />
All this worked well beyond initial plans, and a growing number of people started using Arduino, contribution upgrades, documenting projects, additionnal modules and features... today, the community is extremely active and powerful. There are an incredible number of sensors, actuators, code and project example out there for anyone to learn from and use in whatever project they like, making a wide range of project much, much easier to achieve.<br />
<br />
==== Anatomy of an Arduino electronic board ====<br />
Arduino nano board: picture, feature sheet, etc...<br />
<br />
In this training, we'll use an all integrated board: the Arduino Nano<br />
<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg picture of a Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png pinout of a Arduino Nano]<br />
<br />
==== Features of our Arduino board ====<br />
Added to the CPU (that executes the software that we write) and the memory (flash, to store the data even when the power is out, and RAM for the value we're working on), the microcontroler on the Arduino board knows various different tricks:<br />
* A bit more than ten inputs that we call "digital": the mcu can "see" the presence or absence of a voltage, at defined levels. Our program is able to read the value of the voltage on a pin that is configured as an input, and we can use the value read in our program. We use the term "high" and "low" level, for a voltage of 0v or 5v between that pin and the GND pin of the microcontroller.<br />
* These pins can also be configured as outputs: here, it is the CPU (and thus, our program) that forces the voltage level, either high (5v) or low (0v). Warning: there is a power limit on what each pin and the whole mcu can provide! Each pin can source (eg, it flows out of the chip) or sink (eg it flows in the chip) 20mA, not more. It is the power level required to light an average LED... moving an electric bike may require 1000 times more power: the mcu cannot do this without additionnal circuitry.<br />
* Analog voltage inputs (between 0v and 5v): the mcu we use has a very useful peripheral: an Analog Digital Converter. It can convert an analog voltage (here, between 0 and 5v) present on a specific input pin (6 of them on our board) into a value between 0 and 1023. Why this range? It uses 10 bits numbers. So for exemple, if there is a voltage of 2.5v on an analog input pin, the ADC will read a value of 512 (1023*2.5v/5v = 512).<br />
* For various reasons, there is no easy way to generate an output other than 0v or 5v... dont worry, we'll see how to achieve this with different tricks later !<br />
<br />
The mcu we use also contains all the required hardware to communicate with a computer. It also has lots of other peripherals and things more sophisticated, that can be learnt about later. Please read the datasheet, that is an exhaustive source of information on the chip's features.<br />
<br />
Note: it has enough RAM (to store variables) and flash memory (to store our program) for most of the applications we can work on.<br />
<br />
==== Use the software tool ====<br />
We use the Arduino IDE to write our program, compile (eg transform from human readable to machine usable) it and transfer it to the Arduino board memory through the USB connexion.<br />
<br />
<br />
* menus: chose board & port, access the example projects<br />
* buttons: upload, launch terminal/serial monitor<br />
* <br />
TODO: lots of pictures<br />
<br />
==== Software install ====<br />
'''Installation/verification of the IDE and driver.'''<br />
Note: this should be on anoter page..? just refer to the official page?<br />
<br />
TODO: pictures de partout.<br />
<br />
* howto install IDE : see official website<br />
* howto install driver: harder, as it seems that no website is stable enough as a reference...<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== What's in the starterkit? ===<br />
Let's check out the Arduino Starterkit contents.<br />
<br />
TODO: lots of pictures ; maybe link to other pages instead (eg doc of the kit)<br />
<br />
*Breadboard <br />
** describe how it works<br />
** explain how to create a circuit<br />
* component X: TODO<br />
<br />
== Outputs==<br />
Let's get our hands dirty with the output capabilities of the Arduino.<br />
The first example ever is to play with a LED.<br />
<br />
=== Turn on and off a LED ===<br />
<br />
==== "blink" example and basic functions ====<br />
Our first program is named "Blink", it blinks a LED. It is an example program provided by the Arduino IDE. It can be found in File/Example/Basics.<br />
<br />
Once you've opened this project, clic on the "upload" button to compile the code, and transfer the resulting binary into the mcu flash memory. As a result, the LED called "L", that is connected to pin 13 on an Arduino, blinks at a steady pace.<br />
<br />
This rather simple test is the traditionnal first step with any new mcu platform: congratulations, you've just made your first step with an Arduino :)<br />
<br />
<br />
'''Wiring:'''<br />
There is no need to do any type of wiring: everything that is required is already on the Arduino board we use!<br />
<br />
TODO: pictures.<br />
<br />
'''Understanding the schematic:'''<br />
The schematic is very simple: a LED is connected to the D13 pin of the mcu. There is a resistor in serie, to limit the current to an acceptable value. The LED is correctly oriented so that there is current flowing through it when the pin D13 is set at 'HIGH'.<br />
<br />
One can check [https://www.arduino.cc/en/uploads/Main/ArduinoNano30Schematic.pdf the Nano board schematic] to understand, check components values, etc. For example, the resistor is 330 ohm, one can guess that the LED has a threshold value of 2v, so when there's a HIGH value on D13 (eg 5v), there is 3v across the resistor, so a current flowing through it of 3/330 A, which is approximately 10mA: that's alright for a LED that can probably withtand currents up to 50mA, and the mcu that can do 20mA.<br />
<br />
TODO: picture schematic arduino output 13 +resistor + LED, current & voltage.<br />
<br />
'''Source code:'''<br />
Let's check the source code:<br />
* setup() is a function (bloc of instructions) that gets executed when the board powers up. It is useful to do all the setup that we need for our project. Here: explicit that pin 13 shall be an output (output: the MCU drives the state of that pin)<br />
* loop() is a funciton (bloc of instructions) that gets repetedly executed - as a loop. It contains four lines:<br />
** we turn the LED on by driving the pin D13 to HIGH<br />
** we wait for 1000 milliseconds, which is one second<br />
** we turn the LED off by driving the pin D13 to LOW<br />
** we wait for 1000 milliseconds, which is one second<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Challenge 1: change blinking speed ====<br />
Question: how can we change the speed at which the LED blinks?<br />
<br />
Not a theory question: try to change the code to have the LED blink at a different speed, and clic the upload button to check if your modification achieves your goal.<br />
<br />
Answer: {TODO: shall be hidden/spoiler protected!}<br />
* by changing the value 1000, we change the wait time after we turn the LED on and off. For example:<br />
** with the values 200 and 200, the LED blinks 5 times faster<br />
** with the values 2000 and 2000, the LED blinks 2 times slower<br />
** with 500 and 1500, the LED blinks at the same speed, but it is turned on for less long<br />
<br />
Result:<br />
* Understanding of a simple program<br />
* we've immediately done something real with that LED!<br />
<br />
==== Challenge 2: SOS in morse code ====<br />
Question: how can we create more complex blinking patterns? For example, let's do the famous "SOS" in morse code: ...---... which is three short flashes (code for 'S'), three long (code for 'O') and again three short flashes.<br />
<br />
Let's display this on the L LED!<br />
<br />
Remember: even on a simple example, a well structured and cleaned up program is much better.<br />
<br />
<br />
===== Answers to 2.1 =====<br />
* there are several different ways of achieving this:<br />
** copy paste the four lines of code we already know as many times as required, with changed values for the delay() function<br />
** create our own functions, like "short_flash()" and "long_flash()", or display_S() and display_O()<br />
* use parameterized code makes sense:<br />
** having "magic numbers" everywhere we use delay() is problematic: it isnt easy to change these values, and when reading the code, who knows why the value is 1000 or 500?<br />
** Let's create "variables" :<br />
*** const int period_flash_short = 200;<br />
*** const int period_flash_long = 1000;<br />
** We can use these everywhere as required, and then play with the values more easily.<br />
<br />
===== Answer to 2.1 with copy paste =====<br />
void setup() {<br />
pinMode(13, OUTPUT);<br />
}<br />
void loop() {<br />
/* display 's' : three short flashes */<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
<br />
/* display 'o' : three long flashes */<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(1000); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(1000); // wait for a second<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(1000); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(1000); // wait for a second<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(1000); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(1000); // wait for a second<br />
<br />
/* display 's' : three short flashes */<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(200); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(200); // wait for 200ms<br />
}<br />
<br />
===== Answer to 2.1 with functions and parameters =====<br />
const int period_flash_short = 200;<br />
const int period_flash_long = 1000;<br />
<br />
/* short flash: period_flash_short ms on, period_flash_short ms off */<br />
int short_flash(void) {<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(period_flash_short); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(period_flash_short); // wait for 200ms<br />
}<br />
/* short flash: 1s on, 1s off */<br />
int long_flash(void) {<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(period_flash_long); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(period_flash_long); // wait for a second<br />
}<br />
/* display 's' : three short flashes */<br />
void display_S(void) {<br />
short_flash();<br />
short_flash();<br />
short_flash();<br />
}<br />
/* display 'o' : three long flashes */<br />
void display_O(void) {<br />
long_flash();<br />
long_flash();<br />
long_flash();<br />
}<br />
<br />
void setup() {<br />
pinMode(13, OUTPUT);<br />
}<br />
void loop() {<br />
display_S();<br />
display_O();<br />
display_S();<br />
}<br />
<br />
<br />
===== Bonus Question 2.2 =====<br />
How can we change the morse code displaying speed?<br />
<br />
===== Answers to 2.2 =====<br />
Another obvious reason why parameterized code is better than "hardcoded" values.<br />
const int period_flash_base = 200;<br />
const int period_flash_short = 1;<br />
const int period_flash_long = 5;<br />
<br />
/* short flash: period_flash_short ms on, period_flash_short ms off */<br />
int short_flash(void) {<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(period_flash_short*period_flash_base); // wait for 200ms<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(period_flash_short*period_flash_base); // wait for 200ms<br />
}<br />
/* short flash: 1s on, 1s off */<br />
int long_flash(void) {<br />
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)<br />
delay(period_flash_long*period_flash_base); // wait for a second<br />
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW<br />
delay(period_flash_long*period_flash_base); // wait for a second<br />
}<br />
/* display 's' : three short flashes */<br />
void display_S(void) {<br />
short_flash();<br />
short_flash();<br />
short_flash();<br />
}<br />
/* display 'o' : three long flashes */<br />
void display_O(void) {<br />
long_flash();<br />
long_flash();<br />
long_flash();<br />
}<br />
<br />
void setup() {<br />
pinMode(13, OUTPUT);<br />
}<br />
void loop() {<br />
display_S();<br />
display_O();<br />
display_S();<br />
}<br />
<br />
<br />
===== Bonus Question 2.3 =====<br />
How to change the message sent?<br />
<br />
===== Answers to 2.3 =====<br />
We could create a function that takes a character as argument, eg "display_morse(char c)" or similar<br />
void display_morse(char c) {<br />
swithc(c) {<br />
case 's':<br />
short_flash();<br />
short_flash();<br />
short_flash();<br />
break;<br />
<br />
case 'o':<br />
long_flash();<br />
long_flash();<br />
long_flash();<br />
break;<br />
<br />
default:<br />
break;<br />
}<br />
}<br />
<br />
=== Allumer des LED avec intensité variable ===<br />
<br />
==== Défi 3: ultra rapide ====<br />
Question: Il se passe quoi si on fait clignoter suuuper vite?<br />
<br />
Là encore: faites le test! Mettez ''delay(100)'', puis ''delay(10)'' et ''delay(1)''.<br />
<br />
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.<br />
<br />
Question: ajuster la vitesse de clignotement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.<br />
<br />
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 !<br />
<br />
Question: ca veut dire quoi, super vite, pour le microcontrôleur?<br />
<br />
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... <br />
<br />
==== Défi 4 : jouer avec les délais ====<br />
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:Initiation:EnFormations:Arduino:Initiation:En2016-09-26T16:27:30Z<p>Clément: /* Piloter des sorties */</p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Introduction to microcontrollers with the Arduino platform =<br />
Arduino, the famous microcontroler board, makes it easy to hack embedded systems that involves sensors, actuators, programs.<br />
In this workshop, we'll discover what it can do: input, output, communication.<br />
To do so, we'll play with several challenges that an Arduino can easily solve.<br />
<br />
This workshop is open to everyone, and is intended as an help for your first steps in the Arduino world.<br />
<br />
<br />
== Info ==<br />
* Duration: 3h or more<br />
* Target audience: any Electrolab member, beginner level in computer programming/electronics/Arduino<br />
<br />
== Related trainings ==<br />
* prerequisite: nothing special, except ability to read & basic computer skills<br />
* Ideally:<br />
** basic notions of electronics : see corresponding [[Formations:Electronique:Initiation:En|training on this topic]]<br />
** basic notions of (computer) programming : see corresponding [[Formations:Programmation:Initiation:En|training on this topic]]<br />
<br />
* Following trainings:<br />
** My First Arduino Project<br />
<br />
== Equipment ==<br />
It is mandatory to bring your own laptop. You must install the Arduino software before the training. Please refer to https://www.arduino.cc/en/Main/Software<br />
<br />
Examples and exercices on this page use content from the Arduino starterkit, Electrolab version.<br />
This kit is sold 30€, and several kits are also available during the training<br />
<br />
Contents :<br />
* Arduino Nano + USB cable<br />
* breadboard (400p) and cables male/male et female/female<br />
* potentiometer and pushbutton (joystick)<br />
* leds: red, green, yellow, white, blue, RGB and resistor (x8) 330 ohm<br />
* photoresistor & thermistor + adapted resistor set (2x1k, 2x10k, 2x100k)<br />
* micro-servomotor, buzzer<br />
<br />
Warning: the Arduino nano board that we use require a special device driver ! These are dirtycheap clones made in China.<br />
<br />
=== IDE (software) installation ===<br />
(maybe move this section some place else?)<br />
* see https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide<br />
* please note that our boards require the ch340 device driver, that does not come with the IDE installation.<br />
See https://www.google.com/?q=ch340+driver to install the mandatory specific device driver without which our kits wont work<br />
<br />
== Additionnal info ==<br />
To buy equipment:<br />
* the Electrolab sells a few components & modules, additionnaly to the starterkit<br />
* many many shops sell Arduino stuff: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== About Arduino ===<br />
* On their website www.arduino.cc : [https://www.arduino.cc/en/Tutorial/HomePage tutorials] and also [https://www.arduino.cc/en/Tutorial/BuiltInExamples code examples with explanations] <br />
* [https://www.arduino.cc/en/Guide/HomePage a similar page to the one you're reading now], directly on the official website (not as good, of course ;)<br />
* [http://eduscol.education.fr/sti/sites/eduscol.education.fr.sti/files/ressources/techniques/3846/3846-les-cles-de-la-carte-esplora.pdf nice document about the esplora board]<br />
* French speaking reference website: http://eskimon.fr/<br />
* Check out website of shops: Sparkfun, Adafruit Industries, ... have lots of online ressource<br />
* deadtree book: I personnally find "Arduino for dummies" interesting.<br />
<br />
=== About programming ===<br />
* basic notions of computer programming : see our [[Formations:Programmation:Initiation:En|training on this topic]]<br />
* see [https://www.arduino.cc/en/Reference/HomePage this page for Arduino language & reference]<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_g%C3%A9n%C3%A9rale_%C3%A0_la_programmation and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_au_langage_C and similar english page.<br />
<br />
=== About electronics ===<br />
* basic notions of electronics: see our [[Formations:Electronique:Initiation:En|training on this topic]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|on our wiki]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectromagn%C3%A9tisme_et_%C3%A9lectricit%C3%A9 and similar english page.<br />
<br />
= Content of the training =<br />
This is designed to be a training at the Electrolab.<br />
One can probably follow along without coming to the actual training on site... but this page needs more work before this is a good option.<br />
Slides from the training will be published here later on.<br />
<br />
== Introduction ==<br />
This training intends to help you discover microcontrollers and how to use them, by using the Arduino platform.<br />
No special knowledge is required for this training: we'll see along everything we need. Of course, if you want to know more on the topic of electronics and computer programming, you should check out our trainings on these topics.<br />
<br />
Let's see what microcontrolers are, how to use them. This will open the gates to a vast diversity of projects !<br />
<br />
==== Preliminary: notions of electronics and computer programming ====<br />
In this training we'll use:<br />
* elecronics related concepts:<br />
** electricity, voltage/current<br />
** electronic circuit, schematic & component model<br />
* computer programming related concepts:<br />
** what is a computer program? a programming language? How to use this?<br />
** C language semantics and [https://www.arduino.cc/en/Reference/HomePage Arduino specific keywords].<br />
** workflow associated with computer programming: design, writing your program, compiling, testing & bug tracking, ...<br />
We have trainings on these topics.<br />
<br />
In any case, no need to be an expert to follow along the Arduino training: do not hesitate to ask questions along the way, including (most encouraged) to your neighbours.<br />
<br />
=== Microcontrollers ===<br />
To learn more, here's the manufacturer webpage of the central chip that we will use: http://www.atmel.com/devices/atmega328p.aspx<br />
<br />
The main technical reference document is its datasheet. This is a long but very interesting read, that you should at least check out quickly: http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf<br />
<br />
There are course material pages on there: https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR<br />
<br />
<br />
==== What is a microcontroller? ====<br />
A microcontroller is a type of chip that is widespread. It can be seen as a small computer that is all integrated on one silicon chip: processor (CPU), memory (RAM & flash), various input/output managers, various peripherals, ... all in one single tiny chip.<br />
This thing is thus capable of interacting closely with the real world: measure physical values with various sensors, and act upon the world by driving actuators. Inbetween sensing and actuating (input and output), the central processor makes "decisions": it executes the program that has been written by you or someone else, and thus follows strictly the behavior that has been described.<br />
<br />
This is a powerful thing: by just writing a different program, you can completely change the behavior of the system. It is also super flexible, because your program can be arbitrarily complex, and give an also arbitrarily complex behavior to the system.<br />
<br />
TODO: picture of the chip on the board: systemic view, with inputs, arrows, CPU+software, arrows, outputs<br />
<br />
==== What is a microprocessor? ====<br />
We also use the acronym: CPU, central processing unit. That's the thing at the heart of a computer, that executes the instructions corresponding to a program. These instructions are very simple:<br />
* add the value 42 to the memory location #3<br />
* if memory location #3 is zero, go execute instruction two locations lower in program memory.<br />
* otherwise, execute the one one location lower in program memory.<br />
<br />
It is not easy to give computers instructions at such a low level of absstraction (eg, assembly leve), because one has to know exactly what the CPU at hand can or cannot do, and how. Most importantly, it is impossible to give complex orders (with a high level of abstraction), like "display an image" or "compute the average value of a group of values". The natural tendency is to use programming language with more and more evolved, abstract, complex instructions (high level languages), that make the programmer's job easier.<br />
<br />
<br />
Physical implementation of a CPU is a fascinating topic: it's where the fronteer between hardware and software is blurry, and where the magic happens : let's keep it for the "introduction to digital electronics" training...<br />
<br />
==== What is binary and number of bits? ====<br />
CPU can handle only 0 and 1: these a digital circuits. To manipulate "real" number, we use base 2, which considers 1 and 0 as digits to represent any number. For example, the number 6 that you well know (formally, can be written as 6*10^0), can also be written as 2+4, or, with base 2: 1*2^2 + 1*2^1 + 0*2^0, or again 110 (base two). These digits that can be 0 or 1 are called bits, or binary digits.<br />
<br />
One major parameter of CPU design is the size of numbers it can natively handle: it depends on how many digits (bits) it can handle at once for a given number. For example, the microcontroler we use in these Arduino has an 8bits CPU: internally, it uses 8 digits numbers, each digit being either 0 or 1.<br />
<br />
So, that should mean the largest number it can handle is 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. Quite small!<br />
<br />
You may ask: what's up with negative numbers, decimal (eg 1.27) numbers, etc... there are ways to do this, but it isnt easy for a small CPU like the one in the Arduino's microcontroller.<br />
<br />
<br />
See:<br />
* https://fr.wikiversity.org/wiki/Code_de_num%C3%A9ration/Introduction or similar in english<br />
* https://fr.wikipedia.org/wiki/Virgule_fixe fixed point.<br />
* https://fr.wikipedia.org/wiki/IEEE_754 (floating point number representation: warning, this isnt an easy topic)<br />
<br />
==== What are they useful for? Where? ====<br />
Many things: interface sensors & actuators of any kind, and decide behavior through writing a programm makes it possible to create sooo many cool things. For example, a washing machine, a modern car, an elevator, ... many, most if not all everyday objects rely on a microcontroller to function as expected. It could be seen as the brain ot said object.<br />
<br />
TODO: picture of a simple system: input, output, software, for an everyday object.<br />
<br />
For example {any closed loop system, or finite state machine based system, that audience can relate to: washing machine, elevator, ...?)<br />
<br />
<br />
==== How to use it? ====<br />
* system design: first, think and make explicit what it is that you're trying to do. What input will you use, and how? Which outputs do you expect, and when? What is the overal expected behavior? What are the missions/goals?<br />
* hardware design: once this is all clear, design & create the hardware, create the schematic with selected sensors & actuators. It may make sense to separate clearly different modules, and perform hierarchical design: first learn how to get values from this sensor, then, tackle all issues specifically related to that motor, before trying to do everything at once.<br />
* software design: once your hardware is ready, you can work on software: here again, it probably makes sense to start with separate modules: divide to conquer applies here. Try out bits of software, think about your overall design before writing code.<br />
* Tests, bug tracking & modifications to the design: nothing ever works the first time...<br />
<br />
=== The Arduino platform & world ===<br />
Arduino has been design for students in design and artists, which means non specialists in electronics, computer science and embedded systems, to allow them to design and hack things that require a microcontroller. This means that "easy to get started with" is at the first position in the requirement list for Arduino. As we shall soon see, this is quite a success!<br />
<br />
Teaching support: create a tool that is easy to use and allows student to do stuff. Wiring is almost as important as Arduino (boards). Is based on free software, and is itself free, too (as in free speech, not free beer: you still have to buy the boards)<br />
<br />
==== What is Arduino ? ====<br />
Compared to the many boards & platforms that existed before Arduino, several aspects make it 100% more awesome:<br />
* Opensource: it relies on existing opensource projects, and everything that has been added is also published under free licenses. This has the usual advantages of free software.<br />
* Cheap: by design, the board had to cost not more than one meal. Being affordable allows people to actually get one and play with it without the fear to destroy it. It began at around 20€ per board, which was 5x cheaper than similar platforms. Now, dirtycheap clones cost few € each.<br />
* Not a toy or just a teaching contraption: they designed an easy to use and intuitive interface, shortcuts in the programming language, and a robust electronic board. BUT all this relies on "real" tools that professionnals use everyday, making them easier to use. This allows anyone to check what's under the hood after the first few steps, and get your hands dirty if you need or want to.<br />
<br />
All this worked well beyond initial plans, and a growing number of people started using Arduino, contribution upgrades, documenting projects, additionnal modules and features... today, the community is extremely active and powerful. There are an incredible number of sensors, actuators, code and project example out there for anyone to learn from and use in whatever project they like, making a wide range of project much, much easier to achieve.<br />
<br />
==== Anatomy of an Arduino electronic board ====<br />
Arduino nano board: picture, feature sheet, etc...<br />
<br />
In this training, we'll use an all integrated board: the Arduino Nano<br />
<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg picture of a Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png pinout of a Arduino Nano]<br />
<br />
==== Features of our Arduino board ====<br />
Added to the CPU (that executes the software that we write) and the memory (flash, to store the data even when the power is out, and RAM for the value we're working on), the microcontroler on the Arduino board knows various different tricks:<br />
* A bit more than ten inputs that we call "digital": the mcu can "see" the presence or absence of a voltage, at defined levels. Our program is able to read the value of the voltage on a pin that is configured as an input, and we can use the value read in our program. We use the term "high" and "low" level, for a voltage of 0v or 5v between that pin and the GND pin of the microcontroller.<br />
* These pins can also be configured as outputs: here, it is the CPU (and thus, our program) that forces the voltage level, either high (5v) or low (0v). Warning: there is a power limit on what each pin and the whole mcu can provide! Each pin can source (eg, it flows out of the chip) or sink (eg it flows in the chip) 20mA, not more. It is the power level required to light an average LED... moving an electric bike may require 1000 times more power: the mcu cannot do this without additionnal circuitry.<br />
* Analog voltage inputs (between 0v and 5v): the mcu we use has a very useful peripheral: an Analog Digital Converter. It can convert an analog voltage (here, between 0 and 5v) present on a specific input pin (6 of them on our board) into a value between 0 and 1023. Why this range? It uses 10 bits numbers. So for exemple, if there is a voltage of 2.5v on an analog input pin, the ADC will read a value of 512 (1023*2.5v/5v = 512).<br />
* For various reasons, there is no easy way to generate an output other than 0v or 5v... dont worry, we'll see how to achieve this with different tricks later !<br />
<br />
The mcu we use also contains all the required hardware to communicate with a computer. It also has lots of other peripherals and things more sophisticated, that can be learnt about later. Please read the datasheet, that is an exhaustive source of information on the chip's features.<br />
<br />
Note: it has enough RAM (to store variables) and flash memory (to store our program) for most of the applications we can work on.<br />
<br />
==== Use the software tool ====<br />
We use the Arduino IDE to write our program, compile (eg transform from human readable to machine usable) it and transfer it to the Arduino board memory through the USB connexion.<br />
<br />
<br />
* menus: chose board & port, access the example projects<br />
* buttons: upload, launch terminal/serial monitor<br />
* <br />
TODO: lots of pictures<br />
<br />
==== Software install ====<br />
'''Installation/verification of the IDE and driver.'''<br />
Note: this should be on anoter page..? just refer to the official page?<br />
<br />
TODO: pictures de partout.<br />
<br />
* howto install IDE : see official website<br />
* howto install driver: harder, as it seems that no website is stable enough as a reference...<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== What's in the starterkit? ===<br />
Let's check out the Arduino Starterkit contents.<br />
<br />
TODO: lots of pictures ; maybe link to other pages instead (eg doc of the kit)<br />
<br />
*Breadboard <br />
** describe how it works<br />
** explain how to create a circuit<br />
* component X: TODO<br />
<br />
== Outputs==<br />
Let's get our hands dirty with the output capabilities of the Arduino.<br />
The first example ever is to play with a LED.<br />
<br />
=== Turn on and off a LED ===<br />
<br />
==== "blink" example and basic functions ====<br />
Our first program is named "Blink", it blinks a LED. It is an example program provided by the Arduino IDE. It can be found in File/Example/Basics.<br />
<br />
Once you've opened this project, clic on the "upload" button to compile the code, and transfer the resulting binary into the mcu flash memory. As a result, the LED called "L", that is connected to pin 13 on an Arduino, blinks at a steady pace.<br />
<br />
This rather simple test is the traditionnal first step with any new mcu platform: congratulations, you've just made your first step with an Arduino :)<br />
<br />
<br />
'''Wiring:'''<br />
There is no need to do any type of wiring: everything that is required is already on the Arduino board we use!<br />
<br />
TODO: pictures.<br />
<br />
'''Understanding the schematic:'''<br />
The schematic is very simple: a LED is connected to the D13 pin of the mcu. There is a resistor in serie, to limit the current to an acceptable value. The LED is correctly oriented so that there is current flowing through it when the pin D13 is set at 'HIGH'.<br />
<br />
One can check [https://www.arduino.cc/en/uploads/Main/ArduinoNano30Schematic.pdf the Nano board schematic] to understand, check components values, etc. For example, the resistor is 330 ohm, one can guess that the LED has a threshold value of 2v, so when there's a HIGH value on D13 (eg 5v), there is 3v across the resistor, so a current flowing through it of 3/330 A, which is approximately 10mA: that's alright for a LED that can probably withtand currents up to 50mA, and the mcu that can do 20mA.<br />
<br />
TODO: picture schematic arduino output 13 +resistor + LED, current & voltage.<br />
<br />
'''Source code:'''<br />
Let's check the source code:<br />
* setup() is a function (bloc of instructions) that gets executed when the board powers up. It is useful to do all the setup that we need for our project. Here: explicit that pin 13 shall be an output (output: the MCU drives the state of that pin)<br />
* loop() is a funciton (bloc of instructions) that gets repetedly executed - as a loop. It contains four lines:<br />
** we turn the LED on by driving the pin D13 to HIGH<br />
** we wait for 1000 milliseconds, which is one second<br />
** we turn the LED off by driving the pin D13 to LOW<br />
** we wait for 1000 milliseconds, which is one second<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Challenge 1: change blinking speed ====<br />
Question: how can we change the speed at which the LED blinks?<br />
<br />
Not a theory question: try to change the code to have the LED blink at a different speed, and clic the upload button to check if your modification achieves your goal.<br />
<br />
Answer: {TODO: shall be hidden/spoiler protected!}<br />
* by changing the value 1000, we change the wait time after we turn the LED on and off. For example:<br />
** with the values 200 and 200, the LED blinks 5 times faster<br />
** with the values 2000 and 2000, the LED blinks 2 times slower<br />
** with 500 and 1500, the LED blinks at the same speed, but it is turned on for less long<br />
<br />
Result:<br />
* Understanding of a simple program<br />
* we've immediately done something real with that LED!<br />
<br />
==== Défi 2: SOS morse ====<br />
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.<br />
<br />
Question pratique: faites donc un afficheur de SOS en morse sur la led L !<br />
<br />
Réponses: <br />
* diversité d'approches, de stratégies:<br />
** on peut faire de simples copier coller des 4 lignes de l'exemple de départ<br />
** utiliser des fonctions: créer une fonction flash_court() et une fonction flash-long(), par exemple<br />
* 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;<br />
<br />
Résultat:<br />
* on a désormais un programme un peu plus sophistiqué que le simple clignotement<br />
<br />
<br />
Questions subsidiaires:<br />
* 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"<br />
* 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).<br />
<br />
<br />
TODO: pretty print source code de ces questions subsidiaires<br />
<br />
En conclusion: même sur un exemple simple, bien structurer son programme et anticiper ce à quoi il va pouvoir servir est important.<br />
<br />
=== Allumer des LED avec intensité variable ===<br />
<br />
==== Défi 3: ultra rapide ====<br />
Question: Il se passe quoi si on fait clignoter suuuper vite?<br />
<br />
Là encore: faites le test! Mettez ''delay(100)'', puis ''delay(10)'' et ''delay(1)''.<br />
<br />
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.<br />
<br />
Question: ajuster la vitesse de clignotement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.<br />
<br />
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 !<br />
<br />
Question: ca veut dire quoi, super vite, pour le microcontrôleur?<br />
<br />
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... <br />
<br />
==== Défi 4 : jouer avec les délais ====<br />
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clémenthttps://wiki.electrolab.fr/Formations:Programmation:InitiationFormations:Programmation:Initiation2016-09-26T14:45:37Z<p>Clément: </p>
<hr />
<div> Page en cours de creation...<br />
<br />
Probablement qu'on veut découper en plusieurs pages:<br />
* introduction & concepts généraux<br />
* page spécifique pour arduino : langage, projet<br />
* page spécifique pour python : langage, projet<br />
* page spécifique pour processing/java : langage, projet<br />
* page spécifique pour scratch : langage, projet<br />
<br />
= Notions fondamentales de programmation =<br />
Cette formation permet de découvrir ce qu'est la programmation, en s'adressant aux grands débutants:<br />
* C'est quoi un programme? Un ordinateur?<br />
* Découverte très concrète des fondamentaux de l'algorithmique et de la programmation<br />
* Réalisation d'un petit projet encadré, au choix, en langage C (Arduino), Java (Processing), Python, Scratch<br />
Ceci sans oublier la prise en main des outils classiques pour mener à bien son projet.<br />
<br />
Cette formation s'adresse à tous, et permet de mieux comprendre les bases de la programmation pour ensuite aborder tous les projets utilisant un programme informatique.<br />
<br />
== Informations pratiques ==<br />
* Durée: 4h <br />
* Public visé: tous les membres souhaitant mieux comprendre ces notions fondamentales<br />
<br />
== Formations liées ==<br />
* Prérequis: culture générale<br />
* Formations suivantes: plein<br />
<br />
== Matériel requis ==<br />
Ce que nous allons utiliser: <br />
* bouts de papier/cartes/whiteboard/CSIRL stuff<br />
* ordinateur avec<br />
** pour le C/Arduino: IDE Arduino + simulateur ou carte<br />
** pour Python: IDE<br />
** pour Processing: Processing vXXX<br />
** pour Scratch: Scratch 2<br />
<br />
A noter que le lab dispose de tout le matériel nécessaire, mais il est fortement conseillé d'installer les outils sur votre ordinateur avant la séance.<br />
<br />
== Ressources additionnelles ==<br />
Supports externes/doc (à creuser/faire du ménage) :<br />
* ajouter liens pertinents, notamment... wikipedia.<br />
* CSIRL: https://github.com/InfoSansOrdi/CSIRL<br />
* Computer Science à voir...<br />
* references C, Arduino, Python, Scratch<br />
<br />
= Contenu détaillé =<br />
Sans prérequis particulier, cette formation aborde:<br />
* Qu'est ce qu'un programme ? Un ordinateur, au fait, c'est quoi ?<br />
* Découverte très concrète, par la pratique, des fondamentaux de l'algorithmique et de la programmation<br />
* Réalisation d'un petit projet encadré, au choix, en langage C (Arduino), Java (Processing), Python, Scratch<br />
<br />
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). <br />
<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement. <br />
<br />
== Introduction ==<br />
Plan de la formation/Organisation/infos pratiques<br />
Blabla qui rafraichit/fournit les notions de départ, et donne les pointeurs pertinents/fournit le contexte.<br />
<br />
=== Motivation ===<br />
Pourquoi apprendre à programmer?<br />
* logiciel libre: analyser, modifier, produire... et ne pas être que consommateur<br />
* empowerment: rôle/impact de l'informatique, "puissance" de l'outil<br />
* just for fun!<br />
<br />
<br />
L'ordinateur est un outil puissant parce que:<br />
* traite de grandes quantités d'informations<br />
* rapide: milliards d'opérations à la seconde<br />
* interconnecté<br />
* infaillible/inusable<br />
* plutôt bon marché et duplicable<br />
<br />
Savoir comment un ordinateur fonctionne, et s'en servir autrement que comme simple consommateur est une source de pouvoir...<br />
<br />
=== C'est quoi un ordinateur? ===<br />
Différents éléments, la vue d'ensemble :<br />
* CPU, mémoires, I/O<br />
* Operating System, programmes/binaires<br />
* fichiers/data<br />
* interfaces (réseaux, périphériques)<br />
<br />
Et ca fait quoi...? Ca exécute du code/des programmes.<br />
<br />
=== C'est quoi un programme? ===<br />
* Instructions pour un automate stupide pour faire quelque chose: algorithme, description formelle<br />
* Language de programmation (C, java, python: compilé, vm, interprété)<br />
* objet intellectuel correctement conçu<br />
<br />
<br />
== Mon premier programme ==<br />
... sans ordinateur! Dijkstra a dit "Computer Science is no more about computers than astronomy is about telescopes." "l'informatique n'est pas plus la science des ordinateurs que l'astronomie est la science des télescopes"<br />
<br />
On va faire une ou plusieurs activiés dans la série:<br />
* tri de cartes<br />
* dessin<br />
Voir également, pour d'autres jeux d'algorithmique sans ordinateur: http://people.irisa.fr/Martin.Quinson/Mediation/SMN/ et https://github.com/jcb/CSIRL<br />
<br />
Notions:<br />
* l'informatique, c'est pas qu'une affaire d'ordinateur<br />
* universalité de la machine de Turing<br />
* apprendre la programmation, ce n'est pas juste apprendre un langage, et encore moins juste taper du code.<br />
<br />
=== Activité 1: comment trier des cartes ? ===<br />
On utilise 10 cartes avec des numéros, disposées cote à cote, au hasard. Une personne a le droit de les manipuler, et exécute strictement les instructions d'une seconde personne qui dit quoi faire.<br />
<br />
On se rend compte que:<br />
* c'est pas si facile que ca de donner des instructions "strictes" qui soient correctes => programmer, c'est donner une suite d'ordres qui aboutissent au résultat attendu, à un ordinateur, qui est absolument dépourvu d'imagination, et ne fait qu'exécuter bêtement les instructions qu'on lui donne.<br />
* il y a plusieurs manières, plus ou moins efficaces => c'est tout l'art de l'algorithmique, l'étude de la manière optimale d'atteindre un résultat donné.<br />
<br />
=== Activité 2: dessin sur commande ===<br />
On utilise des dessins géométriques "simples", par exemple TODO insert image.<br />
<br />
Travail en binome: une personne voit l'image source (géométrique "simple"), qui doit la décrire à une autre personne (celle-ci ne voit pas l'image du départ), qui doit la redessiner à l'identique en suivant les instructions données à la lettre.<br />
<br />
Cela permet d'insister/de voir sur un exemple plus marrant, que c'est pas simple de décrire de manière stricte une séquence d'actions qui donnent un résultat donné.<br />
<br />
== Utiliser un ordinateur pour programmer ==<br />
Actions/activites:<br />
* installer et faire marcher les outils/l'IDE<br />
* pratiquer les exemples de découverte des langages<br />
<br />
Notions/objectifs:<br />
* être plus qu'un simple utilisateur d'ordinateur<br />
* premiers pas concrets avec la programmation<br />
<br />
<br />
=== Comment on fait pour lui donner des ordres? ===<br />
On veut faire faire des choses au final au CPU: instructions basiques :"case mémoire x recoit case mémoire y plus case mémoire z", ou encore "si case mémoire x a pour valeur 42, va à la ligne de programme 1234". Cela s'appelle "langage machine", ou "binaire"/"exécutable". C'est compliqué et fastidieux. On utilise plutot des langages de programmation et des bouts de code préexistants, avec des instructions plus complexes: est-ce que la phrase X contient le mot Y ? Dans tous les cas, au final, le système va exécuter des instructions basiques, mais l'humain décrit son programme dans un langage de programmation - qui peut être de plus haut niveau.<br />
<br />
=== kesako langage de programmation ? ===<br />
Différents types:<br />
* compilé vers langage machine: le C et Arduino/wiring par exemple. Avantage: performance/proximité avec matériel, inconvénient: portabilité/concision<br />
* compilé vers VM: java ; la VM est un programme, si un système possède une VM java, il peut exécuter un binaire java. Voir processing (langage)<br />
* interprêté: exemple le Python. Tout système ayant un interpréteur Python peut exécuter des scripts python<br />
<br />
Comment choisir? En fonction de l'usage final. Comme pour les langues, plus on en connait, mieux on se porte. Pour la formation, on prend "deux extremes": C et Arduino, très proche du matériel, mais assez peu sophistiqué, et Python, versatile mais éloigné du matériel. Processing/Java: polyvalent.<br />
<br />
<br />
=== Les grands points communs ===<br />
Structures de contrôle, etc etc etc...<br />
<br />
Rappel: Ordinateur = stupide automate. Langage de programmation a une définition stricte: la syntaxe (la forme) et ses fautes, ainsi que la sémantique (le fond) et ses erreurs (bugs).<br />
<br />
Il y a des points communs d'un langage à l'autre, mais on va les voir séparément. Choisir un langage par participant ou par session?<br />
<br />
== Programmer en C avec Arduino ==<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Java avec Processing ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Python ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Mon premier projet de programmation ==<br />
Mise en pratique sur un petit projet: regroupe/remixe plusieurs notions abordées lors de la découverte.<br />
<br />
Sous le meme format de pas à pas, avec découverte type défi/conseil/réponse pour chaque étape.<br />
<br />
Actions/activites: un petit projet non trivial complet<br />
<br />
Notions:<br />
* je peux faire des choses! apprendre en faisant, essai/erreur facile avec un ordinateur.<br />
* programmer c'est 5% taper du code, 45% de réflexion/conception et le reste en test/debug/correction de problemes!<br />
<br />
=== Projets C et Arduino ===<br />
On peut faire du C sans Arduino...<br />
<br />
==== systeme de feux tricolores ====<br />
machine d'état classique/bete et méchante...<br />
<br />
==== Système asservi: température bouilloire? ====<br />
problématique capteur/actionneur & asservissement.<br />
<br />
==== Robot dessineur ====<br />
LOGO turtle<br />
<br />
=== Projets Python ===<br />
==== Pygame ====<br />
Petit Jeu Con quelconque... <br />
<br />
==== Traitement d'image? De texte? ====<br />
Trucs "de base" de python<br />
<br />
==== Web related ====<br />
Trouver un exemple pertinent... et abordable<br />
<br />
<br />
== Conclusion ==<br />
Cette formation a permis {Résumé}: <br />
* Chapitre 1 <br />
* Chapitre 2 <br />
* Chapitre 3<br />
<br />
La suite (par exemple) : <br />
* Animer vous meme cette formation! <br />
* autres formations...<br />
<br />
=> Critiquez la formation, appropriez vous le contenu. <br />
<br />
A vous la parole (links pour feedback)</div>Clémenthttps://wiki.electrolab.fr/Formations:Programmation:InitiationFormations:Programmation:Initiation2016-09-26T14:40:12Z<p>Clément: /* Utiliser un ordinateur pour programmer */</p>
<hr />
<div> Page en cours de creation...<br />
= Notions fondamentales de programmation =<br />
Cette formation permet de découvrir ce qu'est la programmation, en s'adressant aux grands débutants:<br />
* C'est quoi un programme? Un ordinateur?<br />
* Découverte très concrète des fondamentaux de l'algorithmique et de la programmation<br />
* Réalisation d'un petit projet encadré, au choix, en langage C (Arduino), Java (Processing), Python, Scratch<br />
Ceci sans oublier la prise en main des outils classiques pour mener à bien son projet.<br />
<br />
Cette formation s'adresse à tous, et permet de mieux comprendre les bases de la programmation pour ensuite aborder tous les projets utilisant un programme informatique.<br />
<br />
== Informations pratiques ==<br />
* Durée: 4h <br />
* Public visé: tous les membres souhaitant mieux comprendre ces notions fondamentales<br />
<br />
== Formations liées ==<br />
* Prérequis: culture générale<br />
* Formations suivantes: plein<br />
<br />
== Matériel requis ==<br />
Ce que nous allons utiliser: <br />
* bouts de papier/cartes/whiteboard/CSIRL stuff<br />
* ordinateur avec<br />
** pour le C/Arduino: IDE Arduino + simulateur ou carte<br />
** pour Python: IDE<br />
** pour Processing: Processing vXXX<br />
** pour Scratch: Scratch 2<br />
<br />
A noter que le lab dispose de tout le matériel nécessaire, mais il est fortement conseillé d'installer les outils sur votre ordinateur avant la séance.<br />
<br />
== Ressources additionnelles ==<br />
Supports externes/doc (à creuser/faire du ménage) :<br />
* ajouter liens pertinents, notamment... wikipedia.<br />
* CSIRL: https://github.com/InfoSansOrdi/CSIRL<br />
* Computer Science à voir...<br />
* references C, Arduino, Python, Scratch<br />
<br />
= Contenu détaillé =<br />
Sans prérequis particulier, cette formation aborde:<br />
* Qu'est ce qu'un programme ? Un ordinateur, au fait, c'est quoi ?<br />
* Découverte très concrète, par la pratique, des fondamentaux de l'algorithmique et de la programmation<br />
* Réalisation d'un petit projet encadré, au choix, en langage C (Arduino), Java (Processing), Python, Scratch<br />
<br />
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). <br />
<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement. <br />
<br />
== Introduction ==<br />
Plan de la formation/Organisation/infos pratiques<br />
Blabla qui rafraichit/fournit les notions de départ, et donne les pointeurs pertinents/fournit le contexte.<br />
<br />
=== Motivation ===<br />
Pourquoi apprendre à programmer?<br />
* logiciel libre: analyser, modifier, produire... et ne pas être que consommateur<br />
* empowerment: rôle/impact de l'informatique, "puissance" de l'outil<br />
* just for fun!<br />
<br />
<br />
L'ordinateur est un outil puissant parce que:<br />
* traite de grandes quantités d'informations<br />
* rapide: milliards d'opérations à la seconde<br />
* interconnecté<br />
* infaillible/inusable<br />
* plutôt bon marché et duplicable<br />
<br />
Savoir comment un ordinateur fonctionne, et s'en servir autrement que comme simple consommateur est une source de pouvoir...<br />
<br />
=== C'est quoi un ordinateur? ===<br />
Différents éléments, la vue d'ensemble :<br />
* CPU, mémoires, I/O<br />
* Operating System, programmes/binaires<br />
* fichiers/data<br />
* interfaces (réseaux, périphériques)<br />
<br />
Et ca fait quoi...? Ca exécute du code/des programmes.<br />
<br />
=== C'est quoi un programme? ===<br />
* Instructions pour un automate stupide pour faire quelque chose: algorithme, description formelle<br />
* Language de programmation (C, java, python: compilé, vm, interprété)<br />
* objet intellectuel correctement conçu<br />
<br />
<br />
== Mon premier programme ==<br />
... sans ordinateur! Dijkstra a dit "Computer Science is no more about computers than astronomy is about telescopes." "l'informatique n'est pas plus la science des ordinateurs que l'astronomie est la science des télescopes"<br />
<br />
On va faire une ou plusieurs activiés dans la série:<br />
* tri de cartes<br />
* dessin<br />
Voir également, pour d'autres jeux d'algorithmique sans ordinateur: http://people.irisa.fr/Martin.Quinson/Mediation/SMN/ et https://github.com/jcb/CSIRL<br />
<br />
Notions:<br />
* l'informatique, c'est pas qu'une affaire d'ordinateur<br />
* universalité de la machine de Turing<br />
* apprendre la programmation, ce n'est pas juste apprendre un langage, et encore moins juste taper du code.<br />
<br />
=== Activité 1: comment trier des cartes ? ===<br />
On utilise 10 cartes avec des numéros, disposées cote à cote, au hasard. Une personne a le droit de les manipuler, et exécute strictement les instructions d'une seconde personne qui dit quoi faire.<br />
<br />
On se rend compte que:<br />
* c'est pas si facile que ca de donner des instructions "strictes" qui soient correctes => programmer, c'est donner une suite d'ordres qui aboutissent au résultat attendu, à un ordinateur, qui est absolument dépourvu d'imagination, et ne fait qu'exécuter bêtement les instructions qu'on lui donne.<br />
* il y a plusieurs manières, plus ou moins efficaces => c'est tout l'art de l'algorithmique, l'étude de la manière optimale d'atteindre un résultat donné.<br />
<br />
=== Activité 2: dessin sur commande ===<br />
On utilise des dessins géométriques "simples", par exemple TODO insert image.<br />
<br />
Travail en binome: une personne voit l'image source (géométrique "simple"), qui doit la décrire à une autre personne (celle-ci ne voit pas l'image du départ), qui doit la redessiner à l'identique en suivant les instructions données à la lettre.<br />
<br />
Cela permet d'insister/de voir sur un exemple plus marrant, que c'est pas simple de décrire de manière stricte une séquence d'actions qui donnent un résultat donné.<br />
<br />
== Utiliser un ordinateur pour programmer ==<br />
Actions/activites:<br />
* installer et faire marcher les outils/l'IDE<br />
* pratiquer les exemples de découverte des langages<br />
<br />
Notions/objectifs:<br />
* être plus qu'un simple utilisateur d'ordinateur<br />
* premiers pas concrets avec la programmation<br />
<br />
<br />
=== Comment on fait pour lui donner des ordres? ===<br />
On veut faire faire des choses au final au CPU: instructions basiques :"case mémoire x recoit case mémoire y plus case mémoire z", ou encore "si case mémoire x a pour valeur 42, va à la ligne de programme 1234". Cela s'appelle "langage machine", ou "binaire"/"exécutable". C'est compliqué et fastidieux. On utilise plutot des langages de programmation et des bouts de code préexistants, avec des instructions plus complexes: est-ce que la phrase X contient le mot Y ? Dans tous les cas, au final, le système va exécuter des instructions basiques, mais l'humain décrit son programme dans un langage de programmation - qui peut être de plus haut niveau.<br />
<br />
=== kesako langage de programmation ? ===<br />
Différents types:<br />
* compilé vers langage machine: le C et Arduino/wiring par exemple. Avantage: performance/proximité avec matériel, inconvénient: portabilité/concision<br />
* compilé vers VM: java ; la VM est un programme, si un système possède une VM java, il peut exécuter un binaire java. Voir processing (langage)<br />
* interprêté: exemple le Python. Tout système ayant un interpréteur Python peut exécuter des scripts python<br />
<br />
Comment choisir? En fonction de l'usage final. Comme pour les langues, plus on en connait, mieux on se porte. Pour la formation, on prend "deux extremes": C et Arduino, très proche du matériel, mais assez peu sophistiqué, et Python, versatile mais éloigné du matériel. Processing/Java: polyvalent.<br />
<br />
<br />
=== Les grands points communs ===<br />
Structures de contrôle, etc etc etc...<br />
<br />
Rappel: Ordinateur = stupide automate. Langage de programmation a une définition stricte: la syntaxe (la forme) et ses fautes, ainsi que la sémantique (le fond) et ses erreurs (bugs).<br />
<br />
Il y a des points communs d'un langage à l'autre, mais on va les voir séparément. Choisir un langage par participant ou par session?<br />
<br />
== Programmer en C avec Arduino ==<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Java avec Processing ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Python ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Mon premier projet de programmation ==<br />
Mise en pratique sur un petit projet: regroupe/remixe plusieurs notions abordées lors de la découverte.<br />
<br />
Sous le meme format de pas à pas, avec découverte type défi/conseil/réponse pour chaque étape.<br />
<br />
Actions/activites: un petit projet non trivial complet<br />
<br />
Notions:<br />
* je peux faire des choses! apprendre en faisant, essai/erreur facile avec un ordinateur.<br />
* programmer c'est 5% taper du code, 45% de réflexion/conception et le reste en test/debug/correction de problemes!<br />
<br />
=== Projets C et Arduino ===<br />
On peut faire du C sans Arduino...<br />
<br />
==== systeme de feux tricolores ====<br />
machine d'état classique/bete et méchante...<br />
<br />
==== Système asservi: température bouilloire? ====<br />
problématique capteur/actionneur & asservissement.<br />
<br />
==== Robot dessineur ====<br />
LOGO turtle<br />
<br />
=== Projets Python ===<br />
==== Pygame ====<br />
Petit Jeu Con quelconque... <br />
<br />
==== Traitement d'image? De texte? ====<br />
Trucs "de base" de python<br />
<br />
==== Web related ====<br />
Trouver un exemple pertinent... et abordable<br />
<br />
<br />
== Conclusion ==<br />
Cette formation a permis {Résumé}: <br />
* Chapitre 1 <br />
* Chapitre 2 <br />
* Chapitre 3<br />
<br />
La suite (par exemple) : <br />
* Animer vous meme cette formation! <br />
* autres formations...<br />
<br />
=> Critiquez la formation, appropriez vous le contenu. <br />
<br />
A vous la parole (links pour feedback)</div>Clémenthttps://wiki.electrolab.fr/Formations:Programmation:InitiationFormations:Programmation:Initiation2016-09-26T14:37:47Z<p>Clément: /* C'est quoi un ordinateur? */</p>
<hr />
<div> Page en cours de creation...<br />
= Notions fondamentales de programmation =<br />
Cette formation permet de découvrir ce qu'est la programmation, en s'adressant aux grands débutants:<br />
* C'est quoi un programme? Un ordinateur?<br />
* Découverte très concrète des fondamentaux de l'algorithmique et de la programmation<br />
* Réalisation d'un petit projet encadré, au choix, en langage C (Arduino), Java (Processing), Python, Scratch<br />
Ceci sans oublier la prise en main des outils classiques pour mener à bien son projet.<br />
<br />
Cette formation s'adresse à tous, et permet de mieux comprendre les bases de la programmation pour ensuite aborder tous les projets utilisant un programme informatique.<br />
<br />
== Informations pratiques ==<br />
* Durée: 4h <br />
* Public visé: tous les membres souhaitant mieux comprendre ces notions fondamentales<br />
<br />
== Formations liées ==<br />
* Prérequis: culture générale<br />
* Formations suivantes: plein<br />
<br />
== Matériel requis ==<br />
Ce que nous allons utiliser: <br />
* bouts de papier/cartes/whiteboard/CSIRL stuff<br />
* ordinateur avec<br />
** pour le C/Arduino: IDE Arduino + simulateur ou carte<br />
** pour Python: IDE<br />
** pour Processing: Processing vXXX<br />
** pour Scratch: Scratch 2<br />
<br />
A noter que le lab dispose de tout le matériel nécessaire, mais il est fortement conseillé d'installer les outils sur votre ordinateur avant la séance.<br />
<br />
== Ressources additionnelles ==<br />
Supports externes/doc (à creuser/faire du ménage) :<br />
* ajouter liens pertinents, notamment... wikipedia.<br />
* CSIRL: https://github.com/InfoSansOrdi/CSIRL<br />
* Computer Science à voir...<br />
* references C, Arduino, Python, Scratch<br />
<br />
= Contenu détaillé =<br />
Sans prérequis particulier, cette formation aborde:<br />
* Qu'est ce qu'un programme ? Un ordinateur, au fait, c'est quoi ?<br />
* Découverte très concrète, par la pratique, des fondamentaux de l'algorithmique et de la programmation<br />
* Réalisation d'un petit projet encadré, au choix, en langage C (Arduino), Java (Processing), Python, Scratch<br />
<br />
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). <br />
<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement. <br />
<br />
== Introduction ==<br />
Plan de la formation/Organisation/infos pratiques<br />
Blabla qui rafraichit/fournit les notions de départ, et donne les pointeurs pertinents/fournit le contexte.<br />
<br />
=== Motivation ===<br />
Pourquoi apprendre à programmer?<br />
* logiciel libre: analyser, modifier, produire... et ne pas être que consommateur<br />
* empowerment: rôle/impact de l'informatique, "puissance" de l'outil<br />
* just for fun!<br />
<br />
<br />
L'ordinateur est un outil puissant parce que:<br />
* traite de grandes quantités d'informations<br />
* rapide: milliards d'opérations à la seconde<br />
* interconnecté<br />
* infaillible/inusable<br />
* plutôt bon marché et duplicable<br />
<br />
Savoir comment un ordinateur fonctionne, et s'en servir autrement que comme simple consommateur est une source de pouvoir...<br />
<br />
=== C'est quoi un ordinateur? ===<br />
Différents éléments, la vue d'ensemble :<br />
* CPU, mémoires, I/O<br />
* Operating System, programmes/binaires<br />
* fichiers/data<br />
* interfaces (réseaux, périphériques)<br />
<br />
Et ca fait quoi...? Ca exécute du code/des programmes.<br />
<br />
=== C'est quoi un programme? ===<br />
* Instructions pour un automate stupide pour faire quelque chose: algorithme, description formelle<br />
* Language de programmation (C, java, python: compilé, vm, interprété)<br />
* objet intellectuel correctement conçu<br />
<br />
<br />
== Mon premier programme ==<br />
... sans ordinateur! Dijkstra a dit "Computer Science is no more about computers than astronomy is about telescopes." "l'informatique n'est pas plus la science des ordinateurs que l'astronomie est la science des télescopes"<br />
<br />
On va faire une ou plusieurs activiés dans la série:<br />
* tri de cartes<br />
* dessin<br />
Voir également, pour d'autres jeux d'algorithmique sans ordinateur: http://people.irisa.fr/Martin.Quinson/Mediation/SMN/ et https://github.com/jcb/CSIRL<br />
<br />
Notions:<br />
* l'informatique, c'est pas qu'une affaire d'ordinateur<br />
* universalité de la machine de Turing<br />
* apprendre la programmation, ce n'est pas juste apprendre un langage, et encore moins juste taper du code.<br />
<br />
=== Activité 1: comment trier des cartes ? ===<br />
On utilise 10 cartes avec des numéros, disposées cote à cote, au hasard. Une personne a le droit de les manipuler, et exécute strictement les instructions d'une seconde personne qui dit quoi faire.<br />
<br />
On se rend compte que:<br />
* c'est pas si facile que ca de donner des instructions "strictes" qui soient correctes => programmer, c'est donner une suite d'ordres qui aboutissent au résultat attendu, à un ordinateur, qui est absolument dépourvu d'imagination, et ne fait qu'exécuter bêtement les instructions qu'on lui donne.<br />
* il y a plusieurs manières, plus ou moins efficaces => c'est tout l'art de l'algorithmique, l'étude de la manière optimale d'atteindre un résultat donné.<br />
<br />
=== Activité 2: dessin sur commande ===<br />
On utilise des dessins géométriques "simples", par exemple TODO insert image.<br />
<br />
Travail en binome: une personne voit l'image source (géométrique "simple"), qui doit la décrire à une autre personne (celle-ci ne voit pas l'image du départ), qui doit la redessiner à l'identique en suivant les instructions données à la lettre.<br />
<br />
Cela permet d'insister/de voir sur un exemple plus marrant, que c'est pas simple de décrire de manière stricte une séquence d'actions qui donnent un résultat donné.<br />
<br />
== Utiliser un ordinateur pour programmer ==<br />
Actions/activites:<br />
* installer et faire marcher les outils/l'IDE<br />
* pratiquer les exemples de découverte des langages<br />
<br />
Notions/objectifs:<br />
* être plus qu'un simple utilisateur d'ordinateur<br />
* premiers pas concrets avec la programmation<br />
<br />
<br />
=== Comment on fait pour lui donner des ordres? ===<br />
On veut faire faire des choses au final au CPU: instructions basiques :"case mémoire x recoit case mémoire y plus case mémoire z", ou encore "si case mémoire x a pour valeur 42, va à la ligne de programme 1234". Cela s'appelle "langage machine", ou "binaire"/"exécutable". C'est compliqué et fastidieux. On utilise plutot des langages de programmation et des bouts de code préexistants, avec des instructions plus complexes: est-ce que la phrase X contient le mot Y ? Dans tous les cas, au final, le système va exécuter des instructions basiques, mais l'humain décrit son programme dans un langage de programmation - qui peut être de plus haut niveau.<br />
<br />
=== kesako langage de programmation ? ===<br />
Différents types:<br />
* compilé vers langage machine: le C et Arduino/wiring par exemple. Avantage: performance/proximité avec matériel, inconvénient: portabilité/concision<br />
* compilé vers VM: java ; la VM est un programme, si un système possède une VM java, il peut exécuter un binaire java. Voir processing (langage)<br />
* interprêté: exemple le Python. Tout système ayant un interpréteur Python peut exécuter des scripts python<br />
<br />
Comment choisir? En fonction de l'usage final. Comme pour les langues, plus on en connait, mieux on se porte. Pour la formation, on prend "deux extremes": C et Arduino, très proche du matériel, mais assez peu sophistiqué, et Python, versatile mais éloigné du matériel. Processing/Java: polyvalent.<br />
<br />
<br />
Rappel: Ordinateur= stupide automate. Langage de programmation a une définition stricte: la syntaxe (la forme) et ses fautes, ainsi que la sémantique (le fond) et ses erreurs (bugs).<br />
<br />
<br />
Il y a des points communs d'un langage à l'autre, mais on va les voir séparément. Choisir un langage par participant ou par session?<br />
<br />
<br />
VOir si on fait trois sections similaires, ou une trame qui donne les cas spécifiques langage par langage.... probablement d'abord trame, puis cas pratiques, eg:<br />
* toolchain<br />
* notions syntaxe/sémantique: variable, conditionnels, blocs { }, fonctions, stdlib/API<br />
<br />
== Programmer en C avec Arduino ==<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Java avec Processing ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Python ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Mon premier projet de programmation ==<br />
Mise en pratique sur un petit projet: regroupe/remixe plusieurs notions abordées lors de la découverte.<br />
<br />
Sous le meme format de pas à pas, avec découverte type défi/conseil/réponse pour chaque étape.<br />
<br />
Actions/activites: un petit projet non trivial complet<br />
<br />
Notions:<br />
* je peux faire des choses! apprendre en faisant, essai/erreur facile avec un ordinateur.<br />
* programmer c'est 5% taper du code, 45% de réflexion/conception et le reste en test/debug/correction de problemes!<br />
<br />
=== Projets C et Arduino ===<br />
On peut faire du C sans Arduino...<br />
<br />
==== systeme de feux tricolores ====<br />
machine d'état classique/bete et méchante...<br />
<br />
==== Système asservi: température bouilloire? ====<br />
problématique capteur/actionneur & asservissement.<br />
<br />
==== Robot dessineur ====<br />
LOGO turtle<br />
<br />
=== Projets Python ===<br />
==== Pygame ====<br />
Petit Jeu Con quelconque... <br />
<br />
==== Traitement d'image? De texte? ====<br />
Trucs "de base" de python<br />
<br />
==== Web related ====<br />
Trouver un exemple pertinent... et abordable<br />
<br />
<br />
== Conclusion ==<br />
Cette formation a permis {Résumé}: <br />
* Chapitre 1 <br />
* Chapitre 2 <br />
* Chapitre 3<br />
<br />
La suite (par exemple) : <br />
* Animer vous meme cette formation! <br />
* autres formations...<br />
<br />
=> Critiquez la formation, appropriez vous le contenu. <br />
<br />
A vous la parole (links pour feedback)</div>Clémenthttps://wiki.electrolab.fr/Formations:Programmation:InitiationFormations:Programmation:Initiation2016-09-26T14:36:00Z<p>Clément: /* Motivation */</p>
<hr />
<div> Page en cours de creation...<br />
= Notions fondamentales de programmation =<br />
Cette formation permet de découvrir ce qu'est la programmation, en s'adressant aux grands débutants:<br />
* C'est quoi un programme? Un ordinateur?<br />
* Découverte très concrète des fondamentaux de l'algorithmique et de la programmation<br />
* Réalisation d'un petit projet encadré, au choix, en langage C (Arduino), Java (Processing), Python, Scratch<br />
Ceci sans oublier la prise en main des outils classiques pour mener à bien son projet.<br />
<br />
Cette formation s'adresse à tous, et permet de mieux comprendre les bases de la programmation pour ensuite aborder tous les projets utilisant un programme informatique.<br />
<br />
== Informations pratiques ==<br />
* Durée: 4h <br />
* Public visé: tous les membres souhaitant mieux comprendre ces notions fondamentales<br />
<br />
== Formations liées ==<br />
* Prérequis: culture générale<br />
* Formations suivantes: plein<br />
<br />
== Matériel requis ==<br />
Ce que nous allons utiliser: <br />
* bouts de papier/cartes/whiteboard/CSIRL stuff<br />
* ordinateur avec<br />
** pour le C/Arduino: IDE Arduino + simulateur ou carte<br />
** pour Python: IDE<br />
** pour Processing: Processing vXXX<br />
** pour Scratch: Scratch 2<br />
<br />
A noter que le lab dispose de tout le matériel nécessaire, mais il est fortement conseillé d'installer les outils sur votre ordinateur avant la séance.<br />
<br />
== Ressources additionnelles ==<br />
Supports externes/doc (à creuser/faire du ménage) :<br />
* ajouter liens pertinents, notamment... wikipedia.<br />
* CSIRL: https://github.com/InfoSansOrdi/CSIRL<br />
* Computer Science à voir...<br />
* references C, Arduino, Python, Scratch<br />
<br />
= Contenu détaillé =<br />
Sans prérequis particulier, cette formation aborde:<br />
* Qu'est ce qu'un programme ? Un ordinateur, au fait, c'est quoi ?<br />
* Découverte très concrète, par la pratique, des fondamentaux de l'algorithmique et de la programmation<br />
* Réalisation d'un petit projet encadré, au choix, en langage C (Arduino), Java (Processing), Python, Scratch<br />
<br />
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). <br />
<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement. <br />
<br />
== Introduction ==<br />
Plan de la formation/Organisation/infos pratiques<br />
Blabla qui rafraichit/fournit les notions de départ, et donne les pointeurs pertinents/fournit le contexte.<br />
<br />
=== Motivation ===<br />
Pourquoi apprendre à programmer?<br />
* logiciel libre: analyser, modifier, produire... et ne pas être que consommateur<br />
* empowerment: rôle/impact de l'informatique, "puissance" de l'outil<br />
* just for fun!<br />
<br />
<br />
L'ordinateur est un outil puissant parce que:<br />
* traite de grandes quantités d'informations<br />
* rapide: milliards d'opérations à la seconde<br />
* interconnecté<br />
* infaillible/inusable<br />
* plutôt bon marché et duplicable<br />
<br />
Savoir comment un ordinateur fonctionne, et s'en servir autrement que comme simple consommateur est une source de pouvoir...<br />
<br />
=== C'est quoi un ordinateur? ===<br />
Différents éléments, la vue d'ensemble :<br />
* CPU, mémoires, I/O<br />
* Operating System, programmes/binaires<br />
* fichiers/data<br />
* interfaces (réseaux, périphériques)<br />
<br />
=== C'est quoi un programme? ===<br />
* Instructions pour un automate stupide pour faire quelque chose: algorithme, description formelle<br />
* Language de programmation (C, java, python: compilé, vm, interprété)<br />
* objet intellectuel correctement conçu<br />
<br />
<br />
== Mon premier programme ==<br />
... sans ordinateur! Dijkstra a dit "Computer Science is no more about computers than astronomy is about telescopes." "l'informatique n'est pas plus la science des ordinateurs que l'astronomie est la science des télescopes"<br />
<br />
On va faire une ou plusieurs activiés dans la série:<br />
* tri de cartes<br />
* dessin<br />
Voir également, pour d'autres jeux d'algorithmique sans ordinateur: http://people.irisa.fr/Martin.Quinson/Mediation/SMN/ et https://github.com/jcb/CSIRL<br />
<br />
Notions:<br />
* l'informatique, c'est pas qu'une affaire d'ordinateur<br />
* universalité de la machine de Turing<br />
* apprendre la programmation, ce n'est pas juste apprendre un langage, et encore moins juste taper du code.<br />
<br />
=== Activité 1: comment trier des cartes ? ===<br />
On utilise 10 cartes avec des numéros, disposées cote à cote, au hasard. Une personne a le droit de les manipuler, et exécute strictement les instructions d'une seconde personne qui dit quoi faire.<br />
<br />
On se rend compte que:<br />
* c'est pas si facile que ca de donner des instructions "strictes" qui soient correctes => programmer, c'est donner une suite d'ordres qui aboutissent au résultat attendu, à un ordinateur, qui est absolument dépourvu d'imagination, et ne fait qu'exécuter bêtement les instructions qu'on lui donne.<br />
* il y a plusieurs manières, plus ou moins efficaces => c'est tout l'art de l'algorithmique, l'étude de la manière optimale d'atteindre un résultat donné.<br />
<br />
=== Activité 2: dessin sur commande ===<br />
On utilise des dessins géométriques "simples", par exemple TODO insert image.<br />
<br />
Travail en binome: une personne voit l'image source (géométrique "simple"), qui doit la décrire à une autre personne (celle-ci ne voit pas l'image du départ), qui doit la redessiner à l'identique en suivant les instructions données à la lettre.<br />
<br />
Cela permet d'insister/de voir sur un exemple plus marrant, que c'est pas simple de décrire de manière stricte une séquence d'actions qui donnent un résultat donné.<br />
<br />
== Utiliser un ordinateur pour programmer ==<br />
Actions/activites:<br />
* installer et faire marcher les outils/l'IDE<br />
* pratiquer les exemples de découverte des langages<br />
<br />
Notions/objectifs:<br />
* être plus qu'un simple utilisateur d'ordinateur<br />
* premiers pas concrets avec la programmation<br />
<br />
<br />
=== Comment on fait pour lui donner des ordres? ===<br />
On veut faire faire des choses au final au CPU: instructions basiques :"case mémoire x recoit case mémoire y plus case mémoire z", ou encore "si case mémoire x a pour valeur 42, va à la ligne de programme 1234". Cela s'appelle "langage machine", ou "binaire"/"exécutable". C'est compliqué et fastidieux. On utilise plutot des langages de programmation et des bouts de code préexistants, avec des instructions plus complexes: est-ce que la phrase X contient le mot Y ? Dans tous les cas, au final, le système va exécuter des instructions basiques, mais l'humain décrit son programme dans un langage de programmation - qui peut être de plus haut niveau.<br />
<br />
=== kesako langage de programmation ? ===<br />
Différents types:<br />
* compilé vers langage machine: le C et Arduino/wiring par exemple. Avantage: performance/proximité avec matériel, inconvénient: portabilité/concision<br />
* compilé vers VM: java ; la VM est un programme, si un système possède une VM java, il peut exécuter un binaire java. Voir processing (langage)<br />
* interprêté: exemple le Python. Tout système ayant un interpréteur Python peut exécuter des scripts python<br />
<br />
Comment choisir? En fonction de l'usage final. Comme pour les langues, plus on en connait, mieux on se porte. Pour la formation, on prend "deux extremes": C et Arduino, très proche du matériel, mais assez peu sophistiqué, et Python, versatile mais éloigné du matériel. Processing/Java: polyvalent.<br />
<br />
<br />
Rappel: Ordinateur= stupide automate. Langage de programmation a une définition stricte: la syntaxe (la forme) et ses fautes, ainsi que la sémantique (le fond) et ses erreurs (bugs).<br />
<br />
<br />
Il y a des points communs d'un langage à l'autre, mais on va les voir séparément. Choisir un langage par participant ou par session?<br />
<br />
<br />
VOir si on fait trois sections similaires, ou une trame qui donne les cas spécifiques langage par langage.... probablement d'abord trame, puis cas pratiques, eg:<br />
* toolchain<br />
* notions syntaxe/sémantique: variable, conditionnels, blocs { }, fonctions, stdlib/API<br />
<br />
== Programmer en C avec Arduino ==<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Java avec Processing ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Python ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Mon premier projet de programmation ==<br />
Mise en pratique sur un petit projet: regroupe/remixe plusieurs notions abordées lors de la découverte.<br />
<br />
Sous le meme format de pas à pas, avec découverte type défi/conseil/réponse pour chaque étape.<br />
<br />
Actions/activites: un petit projet non trivial complet<br />
<br />
Notions:<br />
* je peux faire des choses! apprendre en faisant, essai/erreur facile avec un ordinateur.<br />
* programmer c'est 5% taper du code, 45% de réflexion/conception et le reste en test/debug/correction de problemes!<br />
<br />
=== Projets C et Arduino ===<br />
On peut faire du C sans Arduino...<br />
<br />
==== systeme de feux tricolores ====<br />
machine d'état classique/bete et méchante...<br />
<br />
==== Système asservi: température bouilloire? ====<br />
problématique capteur/actionneur & asservissement.<br />
<br />
==== Robot dessineur ====<br />
LOGO turtle<br />
<br />
=== Projets Python ===<br />
==== Pygame ====<br />
Petit Jeu Con quelconque... <br />
<br />
==== Traitement d'image? De texte? ====<br />
Trucs "de base" de python<br />
<br />
==== Web related ====<br />
Trouver un exemple pertinent... et abordable<br />
<br />
<br />
== Conclusion ==<br />
Cette formation a permis {Résumé}: <br />
* Chapitre 1 <br />
* Chapitre 2 <br />
* Chapitre 3<br />
<br />
La suite (par exemple) : <br />
* Animer vous meme cette formation! <br />
* autres formations...<br />
<br />
=> Critiquez la formation, appropriez vous le contenu. <br />
<br />
A vous la parole (links pour feedback)</div>Clémenthttps://wiki.electrolab.fr/Formations:Programmation:InitiationFormations:Programmation:Initiation2016-09-26T14:35:33Z<p>Clément: /* Utiliser un ordinateur pour programmer */</p>
<hr />
<div> Page en cours de creation...<br />
= Notions fondamentales de programmation =<br />
Cette formation permet de découvrir ce qu'est la programmation, en s'adressant aux grands débutants:<br />
* C'est quoi un programme? Un ordinateur?<br />
* Découverte très concrète des fondamentaux de l'algorithmique et de la programmation<br />
* Réalisation d'un petit projet encadré, au choix, en langage C (Arduino), Java (Processing), Python, Scratch<br />
Ceci sans oublier la prise en main des outils classiques pour mener à bien son projet.<br />
<br />
Cette formation s'adresse à tous, et permet de mieux comprendre les bases de la programmation pour ensuite aborder tous les projets utilisant un programme informatique.<br />
<br />
== Informations pratiques ==<br />
* Durée: 4h <br />
* Public visé: tous les membres souhaitant mieux comprendre ces notions fondamentales<br />
<br />
== Formations liées ==<br />
* Prérequis: culture générale<br />
* Formations suivantes: plein<br />
<br />
== Matériel requis ==<br />
Ce que nous allons utiliser: <br />
* bouts de papier/cartes/whiteboard/CSIRL stuff<br />
* ordinateur avec<br />
** pour le C/Arduino: IDE Arduino + simulateur ou carte<br />
** pour Python: IDE<br />
** pour Processing: Processing vXXX<br />
** pour Scratch: Scratch 2<br />
<br />
A noter que le lab dispose de tout le matériel nécessaire, mais il est fortement conseillé d'installer les outils sur votre ordinateur avant la séance.<br />
<br />
== Ressources additionnelles ==<br />
Supports externes/doc (à creuser/faire du ménage) :<br />
* ajouter liens pertinents, notamment... wikipedia.<br />
* CSIRL: https://github.com/InfoSansOrdi/CSIRL<br />
* Computer Science à voir...<br />
* references C, Arduino, Python, Scratch<br />
<br />
= Contenu détaillé =<br />
Sans prérequis particulier, cette formation aborde:<br />
* Qu'est ce qu'un programme ? Un ordinateur, au fait, c'est quoi ?<br />
* Découverte très concrète, par la pratique, des fondamentaux de l'algorithmique et de la programmation<br />
* Réalisation d'un petit projet encadré, au choix, en langage C (Arduino), Java (Processing), Python, Scratch<br />
<br />
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). <br />
<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement. <br />
<br />
== Introduction ==<br />
Plan de la formation/Organisation/infos pratiques<br />
Blabla qui rafraichit/fournit les notions de départ, et donne les pointeurs pertinents/fournit le contexte.<br />
<br />
=== Motivation ===<br />
Pourquoi apprendre à programmer?<br />
* logiciel libre: analyser, modifier, produire... et ne pas être que consommateur<br />
* empowerment: rôle/impact de l'informatique, "puissance" de l'outil<br />
* just for fun!<br />
<br />
=== C'est quoi un ordinateur? ===<br />
Différents éléments, la vue d'ensemble :<br />
* CPU, mémoires, I/O<br />
* Operating System, programmes/binaires<br />
* fichiers/data<br />
* interfaces (réseaux, périphériques)<br />
<br />
=== C'est quoi un programme? ===<br />
* Instructions pour un automate stupide pour faire quelque chose: algorithme, description formelle<br />
* Language de programmation (C, java, python: compilé, vm, interprété)<br />
* objet intellectuel correctement conçu<br />
<br />
<br />
== Mon premier programme ==<br />
... sans ordinateur! Dijkstra a dit "Computer Science is no more about computers than astronomy is about telescopes." "l'informatique n'est pas plus la science des ordinateurs que l'astronomie est la science des télescopes"<br />
<br />
On va faire une ou plusieurs activiés dans la série:<br />
* tri de cartes<br />
* dessin<br />
Voir également, pour d'autres jeux d'algorithmique sans ordinateur: http://people.irisa.fr/Martin.Quinson/Mediation/SMN/ et https://github.com/jcb/CSIRL<br />
<br />
Notions:<br />
* l'informatique, c'est pas qu'une affaire d'ordinateur<br />
* universalité de la machine de Turing<br />
* apprendre la programmation, ce n'est pas juste apprendre un langage, et encore moins juste taper du code.<br />
<br />
=== Activité 1: comment trier des cartes ? ===<br />
On utilise 10 cartes avec des numéros, disposées cote à cote, au hasard. Une personne a le droit de les manipuler, et exécute strictement les instructions d'une seconde personne qui dit quoi faire.<br />
<br />
On se rend compte que:<br />
* c'est pas si facile que ca de donner des instructions "strictes" qui soient correctes => programmer, c'est donner une suite d'ordres qui aboutissent au résultat attendu, à un ordinateur, qui est absolument dépourvu d'imagination, et ne fait qu'exécuter bêtement les instructions qu'on lui donne.<br />
* il y a plusieurs manières, plus ou moins efficaces => c'est tout l'art de l'algorithmique, l'étude de la manière optimale d'atteindre un résultat donné.<br />
<br />
=== Activité 2: dessin sur commande ===<br />
On utilise des dessins géométriques "simples", par exemple TODO insert image.<br />
<br />
Travail en binome: une personne voit l'image source (géométrique "simple"), qui doit la décrire à une autre personne (celle-ci ne voit pas l'image du départ), qui doit la redessiner à l'identique en suivant les instructions données à la lettre.<br />
<br />
Cela permet d'insister/de voir sur un exemple plus marrant, que c'est pas simple de décrire de manière stricte une séquence d'actions qui donnent un résultat donné.<br />
<br />
== Utiliser un ordinateur pour programmer ==<br />
Actions/activites:<br />
* installer et faire marcher les outils/l'IDE<br />
* pratiquer les exemples de découverte des langages<br />
<br />
Notions/objectifs:<br />
* être plus qu'un simple utilisateur d'ordinateur<br />
* premiers pas concrets avec la programmation<br />
<br />
<br />
=== Comment on fait pour lui donner des ordres? ===<br />
On veut faire faire des choses au final au CPU: instructions basiques :"case mémoire x recoit case mémoire y plus case mémoire z", ou encore "si case mémoire x a pour valeur 42, va à la ligne de programme 1234". Cela s'appelle "langage machine", ou "binaire"/"exécutable". C'est compliqué et fastidieux. On utilise plutot des langages de programmation et des bouts de code préexistants, avec des instructions plus complexes: est-ce que la phrase X contient le mot Y ? Dans tous les cas, au final, le système va exécuter des instructions basiques, mais l'humain décrit son programme dans un langage de programmation - qui peut être de plus haut niveau.<br />
<br />
=== kesako langage de programmation ? ===<br />
Différents types:<br />
* compilé vers langage machine: le C et Arduino/wiring par exemple. Avantage: performance/proximité avec matériel, inconvénient: portabilité/concision<br />
* compilé vers VM: java ; la VM est un programme, si un système possède une VM java, il peut exécuter un binaire java. Voir processing (langage)<br />
* interprêté: exemple le Python. Tout système ayant un interpréteur Python peut exécuter des scripts python<br />
<br />
Comment choisir? En fonction de l'usage final. Comme pour les langues, plus on en connait, mieux on se porte. Pour la formation, on prend "deux extremes": C et Arduino, très proche du matériel, mais assez peu sophistiqué, et Python, versatile mais éloigné du matériel. Processing/Java: polyvalent.<br />
<br />
<br />
Rappel: Ordinateur= stupide automate. Langage de programmation a une définition stricte: la syntaxe (la forme) et ses fautes, ainsi que la sémantique (le fond) et ses erreurs (bugs).<br />
<br />
<br />
Il y a des points communs d'un langage à l'autre, mais on va les voir séparément. Choisir un langage par participant ou par session?<br />
<br />
<br />
VOir si on fait trois sections similaires, ou une trame qui donne les cas spécifiques langage par langage.... probablement d'abord trame, puis cas pratiques, eg:<br />
* toolchain<br />
* notions syntaxe/sémantique: variable, conditionnels, blocs { }, fonctions, stdlib/API<br />
<br />
== Programmer en C avec Arduino ==<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Java avec Processing ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Python ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Mon premier projet de programmation ==<br />
Mise en pratique sur un petit projet: regroupe/remixe plusieurs notions abordées lors de la découverte.<br />
<br />
Sous le meme format de pas à pas, avec découverte type défi/conseil/réponse pour chaque étape.<br />
<br />
Actions/activites: un petit projet non trivial complet<br />
<br />
Notions:<br />
* je peux faire des choses! apprendre en faisant, essai/erreur facile avec un ordinateur.<br />
* programmer c'est 5% taper du code, 45% de réflexion/conception et le reste en test/debug/correction de problemes!<br />
<br />
=== Projets C et Arduino ===<br />
On peut faire du C sans Arduino...<br />
<br />
==== systeme de feux tricolores ====<br />
machine d'état classique/bete et méchante...<br />
<br />
==== Système asservi: température bouilloire? ====<br />
problématique capteur/actionneur & asservissement.<br />
<br />
==== Robot dessineur ====<br />
LOGO turtle<br />
<br />
=== Projets Python ===<br />
==== Pygame ====<br />
Petit Jeu Con quelconque... <br />
<br />
==== Traitement d'image? De texte? ====<br />
Trucs "de base" de python<br />
<br />
==== Web related ====<br />
Trouver un exemple pertinent... et abordable<br />
<br />
<br />
== Conclusion ==<br />
Cette formation a permis {Résumé}: <br />
* Chapitre 1 <br />
* Chapitre 2 <br />
* Chapitre 3<br />
<br />
La suite (par exemple) : <br />
* Animer vous meme cette formation! <br />
* autres formations...<br />
<br />
=> Critiquez la formation, appropriez vous le contenu. <br />
<br />
A vous la parole (links pour feedback)</div>Clémenthttps://wiki.electrolab.fr/Formations:Programmation:InitiationFormations:Programmation:Initiation2016-09-26T14:31:30Z<p>Clément: /* Contenu détaillé */</p>
<hr />
<div> Page en cours de creation...<br />
= Notions fondamentales de programmation =<br />
Cette formation permet de découvrir ce qu'est la programmation, en s'adressant aux grands débutants:<br />
* C'est quoi un programme? Un ordinateur?<br />
* Découverte très concrète des fondamentaux de l'algorithmique et de la programmation<br />
* Réalisation d'un petit projet encadré, au choix, en langage C (Arduino), Java (Processing), Python, Scratch<br />
Ceci sans oublier la prise en main des outils classiques pour mener à bien son projet.<br />
<br />
Cette formation s'adresse à tous, et permet de mieux comprendre les bases de la programmation pour ensuite aborder tous les projets utilisant un programme informatique.<br />
<br />
== Informations pratiques ==<br />
* Durée: 4h <br />
* Public visé: tous les membres souhaitant mieux comprendre ces notions fondamentales<br />
<br />
== Formations liées ==<br />
* Prérequis: culture générale<br />
* Formations suivantes: plein<br />
<br />
== Matériel requis ==<br />
Ce que nous allons utiliser: <br />
* bouts de papier/cartes/whiteboard/CSIRL stuff<br />
* ordinateur avec<br />
** pour le C/Arduino: IDE Arduino + simulateur ou carte<br />
** pour Python: IDE<br />
** pour Processing: Processing vXXX<br />
** pour Scratch: Scratch 2<br />
<br />
A noter que le lab dispose de tout le matériel nécessaire, mais il est fortement conseillé d'installer les outils sur votre ordinateur avant la séance.<br />
<br />
== Ressources additionnelles ==<br />
Supports externes/doc (à creuser/faire du ménage) :<br />
* ajouter liens pertinents, notamment... wikipedia.<br />
* CSIRL: https://github.com/InfoSansOrdi/CSIRL<br />
* Computer Science à voir...<br />
* references C, Arduino, Python, Scratch<br />
<br />
= Contenu détaillé =<br />
Sans prérequis particulier, cette formation aborde:<br />
* Qu'est ce qu'un programme ? Un ordinateur, au fait, c'est quoi ?<br />
* Découverte très concrète, par la pratique, des fondamentaux de l'algorithmique et de la programmation<br />
* Réalisation d'un petit projet encadré, au choix, en langage C (Arduino), Java (Processing), Python, Scratch<br />
<br />
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). <br />
<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement. <br />
<br />
== Introduction ==<br />
Plan de la formation/Organisation/infos pratiques<br />
Blabla qui rafraichit/fournit les notions de départ, et donne les pointeurs pertinents/fournit le contexte.<br />
<br />
=== Motivation ===<br />
Pourquoi apprendre à programmer?<br />
* logiciel libre: analyser, modifier, produire... et ne pas être que consommateur<br />
* empowerment: rôle/impact de l'informatique, "puissance" de l'outil<br />
* just for fun!<br />
<br />
=== C'est quoi un ordinateur? ===<br />
Différents éléments, la vue d'ensemble :<br />
* CPU, mémoires, I/O<br />
* Operating System, programmes/binaires<br />
* fichiers/data<br />
* interfaces (réseaux, périphériques)<br />
<br />
=== C'est quoi un programme? ===<br />
* Instructions pour un automate stupide pour faire quelque chose: algorithme, description formelle<br />
* Language de programmation (C, java, python: compilé, vm, interprété)<br />
* objet intellectuel correctement conçu<br />
<br />
<br />
== Mon premier programme ==<br />
... sans ordinateur! Dijkstra a dit "Computer Science is no more about computers than astronomy is about telescopes." "l'informatique n'est pas plus la science des ordinateurs que l'astronomie est la science des télescopes"<br />
<br />
On va faire une ou plusieurs activiés dans la série:<br />
* tri de cartes<br />
* dessin<br />
Voir également, pour d'autres jeux d'algorithmique sans ordinateur: http://people.irisa.fr/Martin.Quinson/Mediation/SMN/ et https://github.com/jcb/CSIRL<br />
<br />
Notions:<br />
* l'informatique, c'est pas qu'une affaire d'ordinateur<br />
* universalité de la machine de Turing<br />
* apprendre la programmation, ce n'est pas juste apprendre un langage, et encore moins juste taper du code.<br />
<br />
=== Activité 1: comment trier des cartes ? ===<br />
On utilise 10 cartes avec des numéros, disposées cote à cote, au hasard. Une personne a le droit de les manipuler, et exécute strictement les instructions d'une seconde personne qui dit quoi faire.<br />
<br />
On se rend compte que:<br />
* c'est pas si facile que ca de donner des instructions "strictes" qui soient correctes => programmer, c'est donner une suite d'ordres qui aboutissent au résultat attendu, à un ordinateur, qui est absolument dépourvu d'imagination, et ne fait qu'exécuter bêtement les instructions qu'on lui donne.<br />
* il y a plusieurs manières, plus ou moins efficaces => c'est tout l'art de l'algorithmique, l'étude de la manière optimale d'atteindre un résultat donné.<br />
<br />
=== Activité 2: dessin sur commande ===<br />
On utilise des dessins géométriques "simples", par exemple TODO insert image.<br />
<br />
Travail en binome: une personne voit l'image source (géométrique "simple"), qui doit la décrire à une autre personne (celle-ci ne voit pas l'image du départ), qui doit la redessiner à l'identique en suivant les instructions données à la lettre.<br />
<br />
Cela permet d'insister/de voir sur un exemple plus marrant, que c'est pas simple de décrire de manière stricte une séquence d'actions qui donnent un résultat donné.<br />
<br />
== Utiliser un ordinateur pour programmer ==<br />
Actions/activites:<br />
* installer et faire marcher les outils/l'IDE<br />
* pratiquer les exemples de découverte des langages<br />
<br />
Notions/objectifs:<br />
* être plus qu'un simple utilisateur d'ordinateur<br />
* premiers pas concrets avec la programmation<br />
<br />
<br />
L'ordinateur est un outil puissant parce que:<br />
* traite de grandes quantités d'informations<br />
* rapide: milliards d'opérations à la seconde<br />
* interconnecté<br />
* infaillible/inusable<br />
* plutôt bon marché et duplicable<br />
<br />
Savoir comment un ordinateur fonctionne, et s'en servir autrement que comme simple consommateur est une source de pouvoir...<br />
<br />
=== Comment on fait pour lui donner des ordres? ===<br />
On veut faire faire des choses au final au CPU: instructions basiques :"case mémoire x recoit case mémoire y plus case mémoire z", ou encore "si case mémoire x a pour valeur 42, va à la ligne de programme 1234". Cela s'appelle "langage machine", ou "binaire"/"exécutable". C'est compliqué et fastidieux. On utilise plutot des langages de programmation et des bouts de code préexistants, avec des instructions plus complexes: est-ce que la phrase X contient le mot Y ? Dans tous les cas, au final, le système va exécuter des instructions basiques, mais l'humain décrit son programme dans un langage de programmation - qui peut être de plus haut niveau.<br />
<br />
=== kesako langage de programmation ? ===<br />
Différents types:<br />
* compilé vers langage machine: le C et Arduino/wiring par exemple. Avantage: performance/proximité avec matériel, inconvénient: portabilité/concision<br />
* compilé vers VM: java ; la VM est un programme, si un système possède une VM java, il peut exécuter un binaire java. Voir processing (langage)<br />
* interprêté: exemple le Python. Tout système ayant un interpréteur Python peut exécuter des scripts python<br />
<br />
Comment choisir? En fonction de l'usage final. Comme pour les langues, plus on en connait, mieux on se porte. Pour la formation, on prend "deux extremes": C et Arduino, très proche du matériel, mais assez peu sophistiqué, et Python, versatile mais éloigné du matériel. Processing/Java: polyvalent.<br />
<br />
<br />
Rappel: Ordinateur= stupide automate. Langage de programmation a une définition stricte: la syntaxe (la forme) et ses fautes, ainsi que la sémantique (le fond) et ses erreurs (bugs).<br />
<br />
<br />
Il y a des points communs d'un langage à l'autre, mais on va les voir séparément. Choisir un langage par participant ou par session?<br />
<br />
<br />
VOir si on fait trois sections similaires, ou une trame qui donne les cas spécifiques langage par langage.... probablement d'abord trame, puis cas pratiques, eg:<br />
* toolchain<br />
* notions syntaxe/sémantique: variable, conditionnels, blocs { }, fonctions, stdlib/API<br />
<br />
== Programmer en C avec Arduino ==<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Java avec Processing ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Python ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Mon premier projet de programmation ==<br />
Mise en pratique sur un petit projet: regroupe/remixe plusieurs notions abordées lors de la découverte.<br />
<br />
Sous le meme format de pas à pas, avec découverte type défi/conseil/réponse pour chaque étape.<br />
<br />
Actions/activites: un petit projet non trivial complet<br />
<br />
Notions:<br />
* je peux faire des choses! apprendre en faisant, essai/erreur facile avec un ordinateur.<br />
* programmer c'est 5% taper du code, 45% de réflexion/conception et le reste en test/debug/correction de problemes!<br />
<br />
=== Projets C et Arduino ===<br />
On peut faire du C sans Arduino...<br />
<br />
==== systeme de feux tricolores ====<br />
machine d'état classique/bete et méchante...<br />
<br />
==== Système asservi: température bouilloire? ====<br />
problématique capteur/actionneur & asservissement.<br />
<br />
==== Robot dessineur ====<br />
LOGO turtle<br />
<br />
=== Projets Python ===<br />
==== Pygame ====<br />
Petit Jeu Con quelconque... <br />
<br />
==== Traitement d'image? De texte? ====<br />
Trucs "de base" de python<br />
<br />
==== Web related ====<br />
Trouver un exemple pertinent... et abordable<br />
<br />
<br />
== Conclusion ==<br />
Cette formation a permis {Résumé}: <br />
* Chapitre 1 <br />
* Chapitre 2 <br />
* Chapitre 3<br />
<br />
La suite (par exemple) : <br />
* Animer vous meme cette formation! <br />
* autres formations...<br />
<br />
=> Critiquez la formation, appropriez vous le contenu. <br />
<br />
A vous la parole (links pour feedback)</div>Clémenthttps://wiki.electrolab.fr/Formations:Programmation:InitiationFormations:Programmation:Initiation2016-09-26T14:17:08Z<p>Clément: /* Notions fondamentales de programmation */</p>
<hr />
<div> Page en cours de creation...<br />
= Notions fondamentales de programmation =<br />
Cette formation permet de découvrir ce qu'est la programmation, en s'adressant aux grands débutants:<br />
* C'est quoi un programme? Un ordinateur?<br />
* Découverte très concrète des fondamentaux de l'algorithmique et de la programmation<br />
* Réalisation d'un petit projet encadré, au choix, en langage C (Arduino), Java (Processing), Python, Scratch<br />
Ceci sans oublier la prise en main des outils classiques pour mener à bien son projet.<br />
<br />
Cette formation s'adresse à tous, et permet de mieux comprendre les bases de la programmation pour ensuite aborder tous les projets utilisant un programme informatique.<br />
<br />
== Informations pratiques ==<br />
* Durée: 4h <br />
* Public visé: tous les membres souhaitant mieux comprendre ces notions fondamentales<br />
<br />
== Formations liées ==<br />
* Prérequis: culture générale<br />
* Formations suivantes: plein<br />
<br />
== Matériel requis ==<br />
Ce que nous allons utiliser: <br />
* bouts de papier/cartes/whiteboard/CSIRL stuff<br />
* ordinateur avec<br />
** pour le C/Arduino: IDE Arduino + simulateur ou carte<br />
** pour Python: IDE<br />
** pour Processing: Processing vXXX<br />
** pour Scratch: Scratch 2<br />
<br />
A noter que le lab dispose de tout le matériel nécessaire, mais il est fortement conseillé d'installer les outils sur votre ordinateur avant la séance.<br />
<br />
== Ressources additionnelles ==<br />
Supports externes/doc (à creuser/faire du ménage) :<br />
* ajouter liens pertinents, notamment... wikipedia.<br />
* CSIRL: https://github.com/InfoSansOrdi/CSIRL<br />
* Computer Science à voir...<br />
* references C, Arduino, Python, Scratch<br />
<br />
= Contenu détaillé =<br />
Sans prérequis particulier, cette formation aborde:<br />
* point 1<br />
* point 2<br />
* point 3<br />
<br />
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). <br />
<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement. <br />
<br />
== Introduction ==<br />
Plan de la formation/Organisation/infos pratiques<br />
Blabla qui rafraichit/fournit les notions de départ, et donne les pointeurs pertinents/fournit le contexte.<br />
<br />
=== Motivation ===<br />
Pourquoi apprendre à programmer?<br />
* logiciel libre: analyser, modifier, produire... et ne pas être que consommateur<br />
* empowerment: role/impact de l'informatique, "puissance" de l'outil<br />
* just for fun!<br />
<br />
=== C'est quoi un ordinateur? ===<br />
Différents éléments/ze big picture:<br />
* CPU, mémoires, I/O<br />
* Operating System, programmes/binaires, fichiers/data ; interfaces (réseaux, périphériques)<br />
<br />
=== C'est quoi un programme? ===<br />
* Instructions pour un automate stupide pour faire quelque chose: algorithme, description formelle<br />
* Language de programmation (C, java, python: compilé, vm, interprété)<br />
* objet intellectuel correctement conçu<br />
<br />
<br />
== Mon premier programme ==<br />
... sans ordinateur! Dijkstra a dit "Computer Science is no more about computers than astronomy is about telescopes." "l'informatique n'est pas plus la science des ordinateurs que l'astronomie est la science des télescopes"<br />
<br />
Petit cas pratique: comment trier des cartes avec des numéros? 10 cartes disposés cote à cote, au hasard. Une personne a le droit de les manipuler, et exécute strictement les instructions d'une seconde personne qui dit quoi faire. Ensuite le groupe formalise la démarche (eg l'alorithme).<br />
<br />
On se rend compte que:<br />
* c'est pas trivial<br />
* ya plusieurs manières, plus ou moins efficaces<br />
<br />
Voir: http://people.irisa.fr/Martin.Quinson/Mediation/SMN/ et https://github.com/jcb/CSIRL<br />
<br />
On peut faire la même chose plus ou moins avec LOGO/géométrique (binome description/réalisation)<br />
<br />
Notions:<br />
* l'informatique, c'est pas qu'une affaire d'ordinateur<br />
* universalité de la machine de Turing<br />
* apprendre la programmation, ce n'est pas juste apprendre un langage, et encore moins juste taper du code.<br />
<br />
== Utiliser un ordinateur pour programmer ==<br />
Actions/activites:<br />
* installer et faire marcher les outils/l'IDE<br />
* pratiquer les exemples de découverte des langages (C et python)<br />
<br />
Notions:<br />
* être plus qu'un simple utilisateur d'ordinateur<br />
* premiers pas concrets avec la programmation<br />
<br />
<br />
L'ordinateur est un outil puissant parce que:<br />
* traite de grandes quantités d'informations<br />
* interconnecté<br />
* infaillible/inusable<br />
* cheap/réplicable<br />
On a donc plutot envie de savoir s'en servir... autrement que comme simple consommateur.<br />
<br />
=== Comment on fait pour lui donner des ordres? ===<br />
On veut faire faire des choses au final au CPU: instructions basiques :"case mémoire x recoit case mémoire y plus case mémoire z", ou encore "si case mémoire x a pour valeur 42, va à la ligne de programme 1234". Cela s'appelle "langage machine", ou "binaire"/"exécutable". C'est compliqué et fastidieux. On utilise plutot des langages de programmation et des bouts de code préexistants, avec des instructions plus complexes: est-ce que la phrase X contient le mot Y ? Dans tous les cas, au final, le système va exécuter des instructions basiques, mais l'humain décrit son programme dans un langage de programmation - qui peut être de plus haut niveau.<br />
<br />
=== kesako langage de programmation ? ===<br />
Différents types:<br />
* compilé vers langage machine: le C et Arduino/wiring par exemple. Avantage: performance/proximité avec matériel, inconvénient: portabilité/concision<br />
* compilé vers VM: java ; la VM est un programme, si un système possède une VM java, il peut exécuter un binaire java. Voir processing (langage)<br />
* interprêté: exemple le Python. Tout système ayant un interpréteur Python peut exécuter des scripts python<br />
<br />
Comment choisir? En fonction de l'usage final. Comme pour les langues, plus on en connait, mieux on se porte. Pour la formation, on prend "deux extremes": C et Arduino, très proche du matériel, mais assez peu sophistiqué, et Python, versatile mais éloigné du matériel. Processing/Java: polyvalent.<br />
<br />
<br />
Rappel: Ordinateur= stupide automate. Langage de programmation a une définition stricte: la syntaxe (la forme) et ses fautes, ainsi que la sémantique (le fond) et ses erreurs (bugs).<br />
<br />
<br />
Il y a des points communs d'un langage à l'autre, mais on va les voir séparément. Choisir un langage par participant ou par session?<br />
<br />
<br />
VOir si on fait trois sections similaires, ou une trame qui donne les cas spécifiques langage par langage.... probablement d'abord trame, puis cas pratiques, eg:<br />
* toolchain<br />
* notions syntaxe/sémantique: variable, conditionnels, blocs { }, fonctions, stdlib/API<br />
<br />
== Programmer en C avec Arduino ==<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Java avec Processing ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Programmer en Python ==<br />
<br />
Présentation sommaire du langage: avantages, inconvénients, contexte.<br />
=== outils de développeur ===<br />
* IDE, compiler, etc<br />
* structure d'un projet et fichier(s) types (header, imports, ...)<br />
* workflow<br />
=> install/vérif des outils, jusqu'à avoir un template de projet pret à travailler.<br />
<br />
=== notions ===<br />
Dans le désordre, et à réorganiser selon la prise en main syntaxique/sémantique. Pour chacune, un ou plusieurs exercice/cas pratique, sous forme de défi/hint/réponse(à trouver/expliciter dans chaque cas):<br />
* variables, type (int, float, bool, string) et role<br />
* conditions/boucles (if, for, while, ...)<br />
* fonctions/macro<br />
* stdlib/API standard<br />
<br />
== Mon premier projet de programmation ==<br />
Mise en pratique sur un petit projet: regroupe/remixe plusieurs notions abordées lors de la découverte.<br />
<br />
Sous le meme format de pas à pas, avec découverte type défi/conseil/réponse pour chaque étape.<br />
<br />
Actions/activites: un petit projet non trivial complet<br />
<br />
Notions:<br />
* je peux faire des choses! apprendre en faisant, essai/erreur facile avec un ordinateur.<br />
* programmer c'est 5% taper du code, 45% de réflexion/conception et le reste en test/debug/correction de problemes!<br />
<br />
=== Projets C et Arduino ===<br />
On peut faire du C sans Arduino...<br />
<br />
==== systeme de feux tricolores ====<br />
machine d'état classique/bete et méchante...<br />
<br />
==== Système asservi: température bouilloire? ====<br />
problématique capteur/actionneur & asservissement.<br />
<br />
==== Robot dessineur ====<br />
LOGO turtle<br />
<br />
=== Projets Python ===<br />
==== Pygame ====<br />
Petit Jeu Con quelconque... <br />
<br />
==== Traitement d'image? De texte? ====<br />
Trucs "de base" de python<br />
<br />
==== Web related ====<br />
Trouver un exemple pertinent... et abordable<br />
<br />
<br />
== Conclusion ==<br />
Cette formation a permis {Résumé}: <br />
* Chapitre 1 <br />
* Chapitre 2 <br />
* Chapitre 3<br />
<br />
La suite (par exemple) : <br />
* Animer vous meme cette formation! <br />
* autres formations...<br />
<br />
=> Critiquez la formation, appropriez vous le contenu. <br />
<br />
A vous la parole (links pour feedback)</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:Initiation:EnFormations:Arduino:Initiation:En2016-09-08T16:55:00Z<p>Clément: /* Introduction */</p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Introduction to microcontrollers with the Arduino platform =<br />
Arduino, the famous microcontroler board, makes it easy to hack embedded systems that involves sensors, actuators, programs.<br />
In this workshop, we'll discover what it can do: input, output, communication.<br />
To do so, we'll play with several challenges that an Arduino can easily solve.<br />
<br />
This workshop is open to everyone, and is intended as an help for your first steps in the Arduino world.<br />
<br />
<br />
== Info ==<br />
* Duration: 3h or more<br />
* Target audience: any Electrolab member, beginner level in computer programming/electronics/Arduino<br />
<br />
== Related trainings ==<br />
* prerequisite: nothing special, except ability to read & basic computer skills<br />
* Ideally:<br />
** basic notions of electronics : see corresponding [[Formations:Electronique:Initiation:En|training on this topic]]<br />
** basic notions of (computer) programming : see corresponding [[Formations:Programmation:Initiation:En|training on this topic]]<br />
<br />
* Following trainings:<br />
** My First Arduino Project<br />
<br />
== Equipment ==<br />
It is mandatory to bring your own laptop. You must install the Arduino software before the training. Please refer to https://www.arduino.cc/en/Main/Software<br />
<br />
Examples and exercices on this page use content from the Arduino starterkit, Electrolab version.<br />
This kit is sold 30€, and several kits are also available during the training<br />
<br />
Contents :<br />
* Arduino Nano + USB cable<br />
* breadboard (400p) and cables male/male et female/female<br />
* potentiometer and pushbutton (joystick)<br />
* leds: red, green, yellow, white, blue, RGB and resistor (x8) 330 ohm<br />
* photoresistor & thermistor + adapted resistor set (2x1k, 2x10k, 2x100k)<br />
* micro-servomotor, buzzer<br />
<br />
Warning: the Arduino nano board that we use require a special device driver ! These are dirtycheap clones made in China.<br />
<br />
=== IDE (software) installation ===<br />
(maybe move this section some place else?)<br />
* see https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide<br />
* please note that our boards require the ch340 device driver, that does not come with the IDE installation.<br />
See https://www.google.com/?q=ch340+driver to install the mandatory specific device driver without which our kits wont work<br />
<br />
== Additionnal info ==<br />
To buy equipment:<br />
* the Electrolab sells a few components & modules, additionnaly to the starterkit<br />
* many many shops sell Arduino stuff: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== About Arduino ===<br />
* On their website www.arduino.cc : [https://www.arduino.cc/en/Tutorial/HomePage tutorials] and also [https://www.arduino.cc/en/Tutorial/BuiltInExamples code examples with explanations] <br />
* [https://www.arduino.cc/en/Guide/HomePage a similar page to the one you're reading now], directly on the official website (not as good, of course ;)<br />
* [http://eduscol.education.fr/sti/sites/eduscol.education.fr.sti/files/ressources/techniques/3846/3846-les-cles-de-la-carte-esplora.pdf nice document about the esplora board]<br />
* French speaking reference website: http://eskimon.fr/<br />
* Check out website of shops: Sparkfun, Adafruit Industries, ... have lots of online ressource<br />
* deadtree book: I personnally find "Arduino for dummies" interesting.<br />
<br />
=== About programming ===<br />
* basic notions of computer programming : see our [[Formations:Programmation:Initiation:En|training on this topic]]<br />
* see [https://www.arduino.cc/en/Reference/HomePage this page for Arduino language & reference]<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_g%C3%A9n%C3%A9rale_%C3%A0_la_programmation and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_au_langage_C and similar english page.<br />
<br />
=== About electronics ===<br />
* basic notions of electronics: see our [[Formations:Electronique:Initiation:En|training on this topic]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|on our wiki]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectromagn%C3%A9tisme_et_%C3%A9lectricit%C3%A9 and similar english page.<br />
<br />
= Content of the training =<br />
This is designed to be a training at the Electrolab.<br />
One can probably follow along without coming to the actual training on site... but this page needs more work before this is a good option.<br />
Slides from the training will be published here later on.<br />
<br />
== Introduction ==<br />
This training intends to help you discover microcontrollers and how to use them, by using the Arduino platform.<br />
No special knowledge is required for this training: we'll see along everything we need. Of course, if you want to know more on the topic of electronics and computer programming, you should check out our trainings on these topics.<br />
<br />
Let's see what microcontrolers are, how to use them. This will open the gates to a vast diversity of projects !<br />
<br />
==== Preliminary: notions of electronics and computer programming ====<br />
In this training we'll use:<br />
* elecronics related concepts:<br />
** electricity, voltage/current<br />
** electronic circuit, schematic & component model<br />
* computer programming related concepts:<br />
** what is a computer program? a programming language? How to use this?<br />
** C language semantics and [https://www.arduino.cc/en/Reference/HomePage Arduino specific keywords].<br />
** workflow associated with computer programming: design, writing your program, compiling, testing & bug tracking, ...<br />
We have trainings on these topics.<br />
<br />
In any case, no need to be an expert to follow along the Arduino training: do not hesitate to ask questions along the way, including (most encouraged) to your neighbours.<br />
<br />
=== Microcontrollers ===<br />
To learn more, here's the manufacturer webpage of the central chip that we will use: http://www.atmel.com/devices/atmega328p.aspx<br />
<br />
The main technical reference document is its datasheet. This is a long but very interesting read, that you should at least check out quickly: http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf<br />
<br />
There are course material pages on there: https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR<br />
<br />
<br />
==== What is a microcontroller? ====<br />
A microcontroller is a type of chip that is widespread. It can be seen as a small computer that is all integrated on one silicon chip: processor (CPU), memory (RAM & flash), various input/output managers, various peripherals, ... all in one single tiny chip.<br />
This thing is thus capable of interacting closely with the real world: measure physical values with various sensors, and act upon the world by driving actuators. Inbetween sensing and actuating (input and output), the central processor makes "decisions": it executes the program that has been written by you or someone else, and thus follows strictly the behavior that has been described.<br />
<br />
This is a powerful thing: by just writing a different program, you can completely change the behavior of the system. It is also super flexible, because your program can be arbitrarily complex, and give an also arbitrarily complex behavior to the system.<br />
<br />
TODO: picture of the chip on the board: systemic view, with inputs, arrows, CPU+software, arrows, outputs<br />
<br />
==== What is a microprocessor? ====<br />
We also use the acronym: CPU, central processing unit. That's the thing at the heart of a computer, that executes the instructions corresponding to a program. These instructions are very simple:<br />
* add the value 42 to the memory location #3<br />
* if memory location #3 is zero, go execute instruction two locations lower in program memory.<br />
* otherwise, execute the one one location lower in program memory.<br />
<br />
It is not easy to give computers instructions at such a low level of absstraction (eg, assembly leve), because one has to know exactly what the CPU at hand can or cannot do, and how. Most importantly, it is impossible to give complex orders (with a high level of abstraction), like "display an image" or "compute the average value of a group of values". The natural tendency is to use programming language with more and more evolved, abstract, complex instructions (high level languages), that make the programmer's job easier.<br />
<br />
<br />
Physical implementation of a CPU is a fascinating topic: it's where the fronteer between hardware and software is blurry, and where the magic happens : let's keep it for the "introduction to digital electronics" training...<br />
<br />
==== What is binary and number of bits? ====<br />
CPU can handle only 0 and 1: these a digital circuits. To manipulate "real" number, we use base 2, which considers 1 and 0 as digits to represent any number. For example, the number 6 that you well know (formally, can be written as 6*10^0), can also be written as 2+4, or, with base 2: 1*2^2 + 1*2^1 + 0*2^0, or again 110 (base two). These digits that can be 0 or 1 are called bits, or binary digits.<br />
<br />
One major parameter of CPU design is the size of numbers it can natively handle: it depends on how many digits (bits) it can handle at once for a given number. For example, the microcontroler we use in these Arduino has an 8bits CPU: internally, it uses 8 digits numbers, each digit being either 0 or 1.<br />
<br />
So, that should mean the largest number it can handle is 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. Quite small!<br />
<br />
You may ask: what's up with negative numbers, decimal (eg 1.27) numbers, etc... there are ways to do this, but it isnt easy for a small CPU like the one in the Arduino's microcontroller.<br />
<br />
<br />
See:<br />
* https://fr.wikiversity.org/wiki/Code_de_num%C3%A9ration/Introduction or similar in english<br />
* https://fr.wikipedia.org/wiki/Virgule_fixe fixed point.<br />
* https://fr.wikipedia.org/wiki/IEEE_754 (floating point number representation: warning, this isnt an easy topic)<br />
<br />
==== What are they useful for? Where? ====<br />
Many things: interface sensors & actuators of any kind, and decide behavior through writing a programm makes it possible to create sooo many cool things. For example, a washing machine, a modern car, an elevator, ... many, most if not all everyday objects rely on a microcontroller to function as expected. It could be seen as the brain ot said object.<br />
<br />
TODO: picture of a simple system: input, output, software, for an everyday object.<br />
<br />
For example {any closed loop system, or finite state machine based system, that audience can relate to: washing machine, elevator, ...?)<br />
<br />
<br />
==== How to use it? ====<br />
* system design: first, think and make explicit what it is that you're trying to do. What input will you use, and how? Which outputs do you expect, and when? What is the overal expected behavior? What are the missions/goals?<br />
* hardware design: once this is all clear, design & create the hardware, create the schematic with selected sensors & actuators. It may make sense to separate clearly different modules, and perform hierarchical design: first learn how to get values from this sensor, then, tackle all issues specifically related to that motor, before trying to do everything at once.<br />
* software design: once your hardware is ready, you can work on software: here again, it probably makes sense to start with separate modules: divide to conquer applies here. Try out bits of software, think about your overall design before writing code.<br />
* Tests, bug tracking & modifications to the design: nothing ever works the first time...<br />
<br />
=== The Arduino platform & world ===<br />
Arduino has been design for students in design and artists, which means non specialists in electronics, computer science and embedded systems, to allow them to design and hack things that require a microcontroller. This means that "easy to get started with" is at the first position in the requirement list for Arduino. As we shall soon see, this is quite a success!<br />
<br />
Teaching support: create a tool that is easy to use and allows student to do stuff. Wiring is almost as important as Arduino (boards). Is based on free software, and is itself free, too (as in free speech, not free beer: you still have to buy the boards)<br />
<br />
==== What is Arduino ? ====<br />
Compared to the many boards & platforms that existed before Arduino, several aspects make it 100% more awesome:<br />
* Opensource: it relies on existing opensource projects, and everything that has been added is also published under free licenses. This has the usual advantages of free software.<br />
* Cheap: by design, the board had to cost not more than one meal. Being affordable allows people to actually get one and play with it without the fear to destroy it. It began at around 20€ per board, which was 5x cheaper than similar platforms. Now, dirtycheap clones cost few € each.<br />
* Not a toy or just a teaching contraption: they designed an easy to use and intuitive interface, shortcuts in the programming language, and a robust electronic board. BUT all this relies on "real" tools that professionnals use everyday, making them easier to use. This allows anyone to check what's under the hood after the first few steps, and get your hands dirty if you need or want to.<br />
<br />
All this worked well beyond initial plans, and a growing number of people started using Arduino, contribution upgrades, documenting projects, additionnal modules and features... today, the community is extremely active and powerful. There are an incredible number of sensors, actuators, code and project example out there for anyone to learn from and use in whatever project they like, making a wide range of project much, much easier to achieve.<br />
<br />
==== Anatomy of an Arduino electronic board ====<br />
Arduino nano board: picture, feature sheet, etc...<br />
<br />
In this training, we'll use an all integrated board: the Arduino Nano<br />
<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg picture of a Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png pinout of a Arduino Nano]<br />
<br />
==== Features of our Arduino board ====<br />
Added to the CPU (that executes the software that we write) and the memory (flash, to store the data even when the power is out, and RAM for the value we're working on), the microcontroler on the Arduino board knows various different tricks:<br />
* A bit more than ten inputs that we call "digital": the mcu can "see" the presence or absence of a voltage, at defined levels. Our program is able to read the value of the voltage on a pin that is configured as an input, and we can use the value read in our program. We use the term "high" and "low" level, for a voltage of 0v or 5v between that pin and the GND pin of the microcontroller.<br />
* These pins can also be configured as outputs: here, it is the CPU (and thus, our program) that forces the voltage level, either high (5v) or low (0v). Warning: there is a power limit on what each pin and the whole mcu can provide! Each pin can source (eg, it flows out of the chip) or sink (eg it flows in the chip) 20mA, not more. It is the power level required to light an average LED... moving an electric bike may require 1000 times more power: the mcu cannot do this without additionnal circuitry.<br />
* Analog voltage inputs (between 0v and 5v): the mcu we use has a very useful peripheral: an Analog Digital Converter. It can convert an analog voltage (here, between 0 and 5v) present on a specific input pin (6 of them on our board) into a value between 0 and 1023. Why this range? It uses 10 bits numbers. So for exemple, if there is a voltage of 2.5v on an analog input pin, the ADC will read a value of 512 (1023*2.5v/5v = 512).<br />
* For various reasons, there is no easy way to generate an output other than 0v or 5v... dont worry, we'll see how to achieve this with different tricks later !<br />
<br />
The mcu we use also contains all the required hardware to communicate with a computer. It also has lots of other peripherals and things more sophisticated, that can be learnt about later. Please read the datasheet, that is an exhaustive source of information on the chip's features.<br />
<br />
Note: it has enough RAM (to store variables) and flash memory (to store our program) for most of the applications we can work on.<br />
<br />
==== Use the software tool ====<br />
We use the Arduino IDE to write our program, compile (eg transform from human readable to machine usable) it and transfer it to the Arduino board memory through the USB connexion.<br />
<br />
<br />
* menus: chose board & port, access the example projects<br />
* buttons: upload, launch terminal/serial monitor<br />
* <br />
TODO: lots of pictures<br />
<br />
==== Software install ====<br />
'''Installation/verification of the IDE and driver.'''<br />
Note: this should be on anoter page..? just refer to the official page?<br />
<br />
TODO: pictures de partout.<br />
<br />
* howto install IDE : see official website<br />
* howto install driver: harder, as it seems that no website is stable enough as a reference...<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== What's in the starterkit? ===<br />
Let's check out the Arduino Starterkit contents.<br />
<br />
TODO: lots of pictures ; maybe link to other pages instead (eg doc of the kit)<br />
<br />
*Breadboard <br />
** describe how it works<br />
** explain how to create a circuit<br />
* component X: TODO<br />
<br />
== Piloter des sorties ==<br />
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.<br />
<br />
=== Allumer et éteindre des LED ===<br />
<br />
==== Exemple "blink" et fonctions de base ====<br />
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.<br />
<br />
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.<br />
<br />
Cette manipulation simple représente le B.A.BA de l'utilisation de microcontrôleurs: bravo, vous venez de faire votre premier pas :)<br />
<br />
<br />
'''Le montage:'''<br />
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 ! <br />
<br />
TODO: pictures.<br />
<br />
'''Comprendre le schéma:'''<br />
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.<br />
<br />
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 !<br />
<br />
TODO: picture schematic sortie arduino resistance led.<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient quatre instructions:<br />
** on allume la led, en mettant la sortie 13 à l'état haut<br />
** on attend 1000 millisecondes, soit une seconde<br />
** on éteint la led, en mettant la sortie 13 à l'état bas<br />
** on attend 1000 millisecondes, soit une seconde<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Défi 1: changer la vitesse de clignottement ====<br />
Question: Comment on fait pour changer la vitesse à laquelle clignote la led ?<br />
<br />
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.<br />
<br />
Réponse: {masqué!}<br />
* en changeant la valeur 1000, on modifie le temps d'attente après avoir allumé ou éteint la led. Par exemple:<br />
** en mettant 200 et 200, la led clignote 5 fois plus vite<br />
** en mettant 2000 et 2000, la led clignote 2 fois plus lentement<br />
** en mettant 500 et 1500, la led clignote à la même vitesse, mais est allumée moins longtemps<br />
<br />
Résultat:<br />
* Compréhension d'un premier programme<br />
* Passage immédiat à l'action et interaction immédiate avec le sujet d'étude<br />
<br />
==== Défi 2: SOS morse ====<br />
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.<br />
<br />
Question pratique: faites donc un afficheur de SOS en morse sur la led L !<br />
<br />
Réponses: <br />
* diversité d'approches, de stratégies:<br />
** on peut faire de simples copier coller des 4 lignes de l'exemple de départ<br />
** utiliser des fonctions: créer une fonction flash_court() et une fonction flash-long(), par exemple<br />
* 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;<br />
<br />
Résultat:<br />
* on a désormais un programme un peu plus sophistiqué que le simple clignotement<br />
<br />
<br />
Questions subsidiaires:<br />
* 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"<br />
* 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).<br />
<br />
<br />
TODO: pretty print source code de ces questions subsidiaires<br />
<br />
En conclusion: même sur un exemple simple, bien structurer son programme et anticiper ce à quoi il va pouvoir servir est important.<br />
<br />
=== Allumer des LED avec intensité variable ===<br />
<br />
==== Défi 3: ultra rapide ====<br />
Question: Il se passe quoi si on fait clignoter suuuper vite?<br />
<br />
Là encore: faites le test! Mettez ''delay(100)'', puis ''delay(10)'' et ''delay(1)''.<br />
<br />
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.<br />
<br />
Question: ajuster la vitesse de clignotement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.<br />
<br />
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 !<br />
<br />
Question: ca veut dire quoi, super vite, pour le microcontrôleur?<br />
<br />
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... <br />
<br />
==== Défi 4 : jouer avec les délais ====<br />
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:Initiation:EnFormations:Arduino:Initiation:En2016-09-08T15:39:21Z<p>Clément: /* Content of the training */</p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Introduction to microcontrollers with the Arduino platform =<br />
Arduino, the famous microcontroler board, makes it easy to hack embedded systems that involves sensors, actuators, programs.<br />
In this workshop, we'll discover what it can do: input, output, communication.<br />
To do so, we'll play with several challenges that an Arduino can easily solve.<br />
<br />
This workshop is open to everyone, and is intended as an help for your first steps in the Arduino world.<br />
<br />
<br />
== Info ==<br />
* Duration: 3h or more<br />
* Target audience: any Electrolab member, beginner level in computer programming/electronics/Arduino<br />
<br />
== Related trainings ==<br />
* prerequisite: nothing special, except ability to read & basic computer skills<br />
* Ideally:<br />
** basic notions of electronics : see corresponding [[Formations:Electronique:Initiation:En|training on this topic]]<br />
** basic notions of (computer) programming : see corresponding [[Formations:Programmation:Initiation:En|training on this topic]]<br />
<br />
* Following trainings:<br />
** My First Arduino Project<br />
<br />
== Equipment ==<br />
It is mandatory to bring your own laptop. You must install the Arduino software before the training. Please refer to https://www.arduino.cc/en/Main/Software<br />
<br />
Examples and exercices on this page use content from the Arduino starterkit, Electrolab version.<br />
This kit is sold 30€, and several kits are also available during the training<br />
<br />
Contents :<br />
* Arduino Nano + USB cable<br />
* breadboard (400p) and cables male/male et female/female<br />
* potentiometer and pushbutton (joystick)<br />
* leds: red, green, yellow, white, blue, RGB and resistor (x8) 330 ohm<br />
* photoresistor & thermistor + adapted resistor set (2x1k, 2x10k, 2x100k)<br />
* micro-servomotor, buzzer<br />
<br />
Warning: the Arduino nano board that we use require a special device driver ! These are dirtycheap clones made in China.<br />
<br />
=== IDE (software) installation ===<br />
(maybe move this section some place else?)<br />
* see https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide<br />
* please note that our boards require the ch340 device driver, that does not come with the IDE installation.<br />
See https://www.google.com/?q=ch340+driver to install the mandatory specific device driver without which our kits wont work<br />
<br />
== Additionnal info ==<br />
To buy equipment:<br />
* the Electrolab sells a few components & modules, additionnaly to the starterkit<br />
* many many shops sell Arduino stuff: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== About Arduino ===<br />
* On their website www.arduino.cc : [https://www.arduino.cc/en/Tutorial/HomePage tutorials] and also [https://www.arduino.cc/en/Tutorial/BuiltInExamples code examples with explanations] <br />
* [https://www.arduino.cc/en/Guide/HomePage a similar page to the one you're reading now], directly on the official website (not as good, of course ;)<br />
* [http://eduscol.education.fr/sti/sites/eduscol.education.fr.sti/files/ressources/techniques/3846/3846-les-cles-de-la-carte-esplora.pdf nice document about the esplora board]<br />
* French speaking reference website: http://eskimon.fr/<br />
* Check out website of shops: Sparkfun, Adafruit Industries, ... have lots of online ressource<br />
* deadtree book: I personnally find "Arduino for dummies" interesting.<br />
<br />
=== About programming ===<br />
* basic notions of computer programming : see our [[Formations:Programmation:Initiation:En|training on this topic]]<br />
* see [https://www.arduino.cc/en/Reference/HomePage this page for Arduino language & reference]<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_g%C3%A9n%C3%A9rale_%C3%A0_la_programmation and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_au_langage_C and similar english page.<br />
<br />
=== About electronics ===<br />
* basic notions of electronics: see our [[Formations:Electronique:Initiation:En|training on this topic]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|on our wiki]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectromagn%C3%A9tisme_et_%C3%A9lectricit%C3%A9 and similar english page.<br />
<br />
= Content of the training =<br />
This is designed to be a training at the Electrolab.<br />
One can probably follow along without coming to the actual training on site... but this page needs more work before this is a good option.<br />
Slides from the training will be published here later on.<br />
<br />
== Introduction ==<br />
This training intends to help you discover microcontrollers and how to use them, by using the Arduino platform.<br />
No special knowledge is required for this training: we'll see along everything we need. Of course, if you want to know more on the topic of electronics and computer programming, you should check out our trainings on these topics.<br />
<br />
Let's see what microcontrolers are, how to use them. This will open the gates to a vast diversity of projects !<br />
<br />
==== Preliminary: notions of electronics and computer programming ====<br />
In this training we'll use:<br />
* elecronics related concepts:<br />
** electricity, voltage/current<br />
** electronic circuit, schematic & component model<br />
* computer programming related concepts:<br />
** what is a computer program? a programming language? How to use this?<br />
** C language semantics and [https://www.arduino.cc/en/Reference/HomePage Arduino specific keywords].<br />
** workflow associated with computer programming: design, writing your program, compiling, testing & bug tracking, ...<br />
We have trainings on these topics.<br />
<br />
In any case, no need to be an expert to follow along the Arduino training: do not hesitate to ask questions along the way, including (most encouraged) to your neighbours.<br />
<br />
=== Microcontrollers ===<br />
To learn more, here's the manufacturer webpage of the central chip that we will use: http://www.atmel.com/devices/atmega328p.aspx<br />
<br />
The main technical reference document is its datasheet. This is a long but very interesting read, that you should at least check out quickly: http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf<br />
<br />
There are course material pages on there: https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR<br />
<br />
<br />
==== What is a microcontroller? ====<br />
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.<br />
<br />
TODO: picture d'un chip au centre d'une carte.<br />
<br />
==== What is a microprocessor? ====<br />
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 :<br />
* ajouter la valeur 42 à la case mémoire #3<br />
* si la case mémoire #3 est nulle, aller exécuter l'instruction 2 cases plus bas dans la mémoire programme<br />
* sinon, exécuter celle 1 case plus bas dans la mémoire programme<br />
<br />
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.<br />
<br />
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"...<br />
<br />
==== Qu'est-ce que le binaire et le nombre de bits ? ====<br />
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.<br />
<br />
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.<br />
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 !<br />
<br />
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.<br />
<br />
<br />
Voir:<br />
* https://fr.wikiversity.org/wiki/Code_de_num%C3%A9ration/Introduction<br />
* https://fr.wikipedia.org/wiki/Virgule_fixe<br />
* https://fr.wikipedia.org/wiki/IEEE_754 (norme pour nombres à virgule: attention compliqué!)<br />
<br />
==== A quoi ca sert/où ca sert? ====<br />
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.<br />
<br />
TODO: picture synoptique système d'un objet courant simple, avec visu entrées, sorties, algorithme<br />
<br />
Par exemple: {système quelconque avec asservissement ou FSM, genre controleur de machine à laver? ou d'ascenceur?}<br />
<br />
<br />
==== Comment on s'en sert? ====<br />
* 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?<br />
* 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.<br />
* É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!<br />
* Tests, correctifs & modifications: rien ne marche jamais du premier coup...<br />
<br />
=== L'univers Arduino ===<br />
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!<br />
<br />
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.<br />
<br />
==== C'est quoi Arduino ? ====<br />
Par rapport à plein de cartes qui existaient auparavant, les gens d'Arduino ont fait plusieurs trucs géniaux:<br />
* 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.<br />
* 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.<br />
* 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.<br />
<br />
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.<br />
<br />
==== Anatomie d'une carte Arduino ====<br />
présentation de la Nano: photo, feature sheet.<br />
<br />
Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg image d'une Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png le pinout Arduino Nano]<br />
<br />
==== Fonctionnalités de notre carte Arduino ====<br />
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 :<br />
* 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.<br />
* 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..<br />
* 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).<br />
* 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 !<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Utiliser l'outil logiciel ====<br />
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.<br />
* menus (choix de carte/port, exemples)<br />
* boutons upload & terminal <br />
* fenêtre d'édition du programme<br />
TODO: pictures de partout.<br />
<br />
==== Installation des logiciels ====<br />
'''Installation/verification de l'IDE + du driver.'''<br />
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.<br />
<br />
TODO: pictures de partout.<br />
<br />
* Installation pas à pas de l'IDE<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== Le matériel ===<br />
Nous allons découvrir chacun des éléments du kit de découverte Arduino.<br />
<br />
TODO: pictures de partout ; est-ce qu'on renverrait pas vers des pages ailleurs qui contiennent ces infos?<br />
<br />
*Breadboard <br />
** Décrire comment marche une breadboard<br />
** Mises en garde/comment on fait un circuit<br />
* composant x:<br />
<br />
== Piloter des sorties ==<br />
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.<br />
<br />
=== Allumer et éteindre des LED ===<br />
<br />
==== Exemple "blink" et fonctions de base ====<br />
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.<br />
<br />
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.<br />
<br />
Cette manipulation simple représente le B.A.BA de l'utilisation de microcontrôleurs: bravo, vous venez de faire votre premier pas :)<br />
<br />
<br />
'''Le montage:'''<br />
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 ! <br />
<br />
TODO: pictures.<br />
<br />
'''Comprendre le schéma:'''<br />
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.<br />
<br />
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 !<br />
<br />
TODO: picture schematic sortie arduino resistance led.<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient quatre instructions:<br />
** on allume la led, en mettant la sortie 13 à l'état haut<br />
** on attend 1000 millisecondes, soit une seconde<br />
** on éteint la led, en mettant la sortie 13 à l'état bas<br />
** on attend 1000 millisecondes, soit une seconde<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Défi 1: changer la vitesse de clignottement ====<br />
Question: Comment on fait pour changer la vitesse à laquelle clignote la led ?<br />
<br />
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.<br />
<br />
Réponse: {masqué!}<br />
* en changeant la valeur 1000, on modifie le temps d'attente après avoir allumé ou éteint la led. Par exemple:<br />
** en mettant 200 et 200, la led clignote 5 fois plus vite<br />
** en mettant 2000 et 2000, la led clignote 2 fois plus lentement<br />
** en mettant 500 et 1500, la led clignote à la même vitesse, mais est allumée moins longtemps<br />
<br />
Résultat:<br />
* Compréhension d'un premier programme<br />
* Passage immédiat à l'action et interaction immédiate avec le sujet d'étude<br />
<br />
==== Défi 2: SOS morse ====<br />
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.<br />
<br />
Question pratique: faites donc un afficheur de SOS en morse sur la led L !<br />
<br />
Réponses: <br />
* diversité d'approches, de stratégies:<br />
** on peut faire de simples copier coller des 4 lignes de l'exemple de départ<br />
** utiliser des fonctions: créer une fonction flash_court() et une fonction flash-long(), par exemple<br />
* 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;<br />
<br />
Résultat:<br />
* on a désormais un programme un peu plus sophistiqué que le simple clignotement<br />
<br />
<br />
Questions subsidiaires:<br />
* 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"<br />
* 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).<br />
<br />
<br />
TODO: pretty print source code de ces questions subsidiaires<br />
<br />
En conclusion: même sur un exemple simple, bien structurer son programme et anticiper ce à quoi il va pouvoir servir est important.<br />
<br />
=== Allumer des LED avec intensité variable ===<br />
<br />
==== Défi 3: ultra rapide ====<br />
Question: Il se passe quoi si on fait clignoter suuuper vite?<br />
<br />
Là encore: faites le test! Mettez ''delay(100)'', puis ''delay(10)'' et ''delay(1)''.<br />
<br />
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.<br />
<br />
Question: ajuster la vitesse de clignotement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.<br />
<br />
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 !<br />
<br />
Question: ca veut dire quoi, super vite, pour le microcontrôleur?<br />
<br />
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... <br />
<br />
==== Défi 4 : jouer avec les délais ====<br />
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:Initiation:EnFormations:Arduino:Initiation:En2016-09-08T15:29:09Z<p>Clément: </p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Introduction to microcontrollers with the Arduino platform =<br />
Arduino, the famous microcontroler board, makes it easy to hack embedded systems that involves sensors, actuators, programs.<br />
In this workshop, we'll discover what it can do: input, output, communication.<br />
To do so, we'll play with several challenges that an Arduino can easily solve.<br />
<br />
This workshop is open to everyone, and is intended as an help for your first steps in the Arduino world.<br />
<br />
<br />
== Info ==<br />
* Duration: 3h or more<br />
* Target audience: any Electrolab member, beginner level in computer programming/electronics/Arduino<br />
<br />
== Related trainings ==<br />
* prerequisite: nothing special, except ability to read & basic computer skills<br />
* Ideally:<br />
** basic notions of electronics : see corresponding [[Formations:Electronique:Initiation:En|training on this topic]]<br />
** basic notions of (computer) programming : see corresponding [[Formations:Programmation:Initiation:En|training on this topic]]<br />
<br />
* Following trainings:<br />
** My First Arduino Project<br />
<br />
== Equipment ==<br />
It is mandatory to bring your own laptop. You must install the Arduino software before the training. Please refer to https://www.arduino.cc/en/Main/Software<br />
<br />
Examples and exercices on this page use content from the Arduino starterkit, Electrolab version.<br />
This kit is sold 30€, and several kits are also available during the training<br />
<br />
Contents :<br />
* Arduino Nano + USB cable<br />
* breadboard (400p) and cables male/male et female/female<br />
* potentiometer and pushbutton (joystick)<br />
* leds: red, green, yellow, white, blue, RGB and resistor (x8) 330 ohm<br />
* photoresistor & thermistor + adapted resistor set (2x1k, 2x10k, 2x100k)<br />
* micro-servomotor, buzzer<br />
<br />
Warning: the Arduino nano board that we use require a special device driver ! These are dirtycheap clones made in China.<br />
<br />
=== IDE (software) installation ===<br />
(maybe move this section some place else?)<br />
* see https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide<br />
* please note that our boards require the ch340 device driver, that does not come with the IDE installation.<br />
See https://www.google.com/?q=ch340+driver to install the mandatory specific device driver without which our kits wont work<br />
<br />
== Additionnal info ==<br />
To buy equipment:<br />
* the Electrolab sells a few components & modules, additionnaly to the starterkit<br />
* many many shops sell Arduino stuff: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== About Arduino ===<br />
* On their website www.arduino.cc : [https://www.arduino.cc/en/Tutorial/HomePage tutorials] and also [https://www.arduino.cc/en/Tutorial/BuiltInExamples code examples with explanations] <br />
* [https://www.arduino.cc/en/Guide/HomePage a similar page to the one you're reading now], directly on the official website (not as good, of course ;)<br />
* [http://eduscol.education.fr/sti/sites/eduscol.education.fr.sti/files/ressources/techniques/3846/3846-les-cles-de-la-carte-esplora.pdf nice document about the esplora board]<br />
* French speaking reference website: http://eskimon.fr/<br />
* Check out website of shops: Sparkfun, Adafruit Industries, ... have lots of online ressource<br />
* deadtree book: I personnally find "Arduino for dummies" interesting.<br />
<br />
=== About programming ===<br />
* basic notions of computer programming : see our [[Formations:Programmation:Initiation:En|training on this topic]]<br />
* see [https://www.arduino.cc/en/Reference/HomePage this page for Arduino language & reference]<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_g%C3%A9n%C3%A9rale_%C3%A0_la_programmation and similar english page.<br />
* https://fr.wikiversity.org/wiki/Introduction_au_langage_C and similar english page.<br />
<br />
=== About electronics ===<br />
* basic notions of electronics: see our [[Formations:Electronique:Initiation:En|training on this topic]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|on our wiki]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique and similar english page.<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectromagn%C3%A9tisme_et_%C3%A9lectricit%C3%A9 and similar english page.<br />
<br />
= Content of the training =<br />
Cette formation est prevue pour être animée au lab.<br />
Il est envisageable de suivre le plan en autoformation (mais pour l'instant, cette page nécessite d'être étoffée).<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement.<br />
<br />
== Introduction ==<br />
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.<br />
<br />
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 !<br />
<br />
==== Préliminaires: notions d'électronique et d'informatique ====<br />
Pendant cette formation, nous allons manipuler:<br />
* des notions d'électronique :<br />
** électricité, tension/courant<br />
** circuit électrique, schémas et modèle<br />
* des notions d'informatique :<br />
** qu'est-ce que c'est qu'un programme? langage de programmation.<br />
** sémantique du langage et [https://www.arduino.cc/en/Reference/HomePage mots clés spécifiques Arduino].<br />
** étapes de travail: conception, écriture, compilation, tests & correctifs.<br />
<br />
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.<br />
<br />
<br />
=== Microcontrôleurs ===<br />
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<br />
<br />
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<br />
<br />
https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR<br />
<br />
<br />
==== Qu'est-ce qu'un microcontrôleur? ====<br />
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.<br />
<br />
TODO: picture d'un chip au centre d'une carte.<br />
<br />
==== Qu'est-ce qu'un microprocesseur ? ====<br />
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 :<br />
* ajouter la valeur 42 à la case mémoire #3<br />
* si la case mémoire #3 est nulle, aller exécuter l'instruction 2 cases plus bas dans la mémoire programme<br />
* sinon, exécuter celle 1 case plus bas dans la mémoire programme<br />
<br />
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.<br />
<br />
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"...<br />
<br />
==== Qu'est-ce que le binaire et le nombre de bits ? ====<br />
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.<br />
<br />
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.<br />
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 !<br />
<br />
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.<br />
<br />
<br />
Voir:<br />
* https://fr.wikiversity.org/wiki/Code_de_num%C3%A9ration/Introduction<br />
* https://fr.wikipedia.org/wiki/Virgule_fixe<br />
* https://fr.wikipedia.org/wiki/IEEE_754 (norme pour nombres à virgule: attention compliqué!)<br />
<br />
==== A quoi ca sert/où ca sert? ====<br />
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.<br />
<br />
TODO: picture synoptique système d'un objet courant simple, avec visu entrées, sorties, algorithme<br />
<br />
Par exemple: {système quelconque avec asservissement ou FSM, genre controleur de machine à laver? ou d'ascenceur?}<br />
<br />
<br />
==== Comment on s'en sert? ====<br />
* 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?<br />
* 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.<br />
* É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!<br />
* Tests, correctifs & modifications: rien ne marche jamais du premier coup...<br />
<br />
=== L'univers Arduino ===<br />
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!<br />
<br />
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.<br />
<br />
==== C'est quoi Arduino ? ====<br />
Par rapport à plein de cartes qui existaient auparavant, les gens d'Arduino ont fait plusieurs trucs géniaux:<br />
* 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.<br />
* 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.<br />
* 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.<br />
<br />
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.<br />
<br />
==== Anatomie d'une carte Arduino ====<br />
présentation de la Nano: photo, feature sheet.<br />
<br />
Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg image d'une Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png le pinout Arduino Nano]<br />
<br />
==== Fonctionnalités de notre carte Arduino ====<br />
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 :<br />
* 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.<br />
* 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..<br />
* 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).<br />
* 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 !<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Utiliser l'outil logiciel ====<br />
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.<br />
* menus (choix de carte/port, exemples)<br />
* boutons upload & terminal <br />
* fenêtre d'édition du programme<br />
TODO: pictures de partout.<br />
<br />
==== Installation des logiciels ====<br />
'''Installation/verification de l'IDE + du driver.'''<br />
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.<br />
<br />
TODO: pictures de partout.<br />
<br />
* Installation pas à pas de l'IDE<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== Le matériel ===<br />
Nous allons découvrir chacun des éléments du kit de découverte Arduino.<br />
<br />
TODO: pictures de partout ; est-ce qu'on renverrait pas vers des pages ailleurs qui contiennent ces infos?<br />
<br />
*Breadboard <br />
** Décrire comment marche une breadboard<br />
** Mises en garde/comment on fait un circuit<br />
* composant x:<br />
<br />
== Piloter des sorties ==<br />
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.<br />
<br />
=== Allumer et éteindre des LED ===<br />
<br />
==== Exemple "blink" et fonctions de base ====<br />
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.<br />
<br />
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.<br />
<br />
Cette manipulation simple représente le B.A.BA de l'utilisation de microcontrôleurs: bravo, vous venez de faire votre premier pas :)<br />
<br />
<br />
'''Le montage:'''<br />
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 ! <br />
<br />
TODO: pictures.<br />
<br />
'''Comprendre le schéma:'''<br />
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.<br />
<br />
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 !<br />
<br />
TODO: picture schematic sortie arduino resistance led.<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient quatre instructions:<br />
** on allume la led, en mettant la sortie 13 à l'état haut<br />
** on attend 1000 millisecondes, soit une seconde<br />
** on éteint la led, en mettant la sortie 13 à l'état bas<br />
** on attend 1000 millisecondes, soit une seconde<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Défi 1: changer la vitesse de clignottement ====<br />
Question: Comment on fait pour changer la vitesse à laquelle clignote la led ?<br />
<br />
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.<br />
<br />
Réponse: {masqué!}<br />
* en changeant la valeur 1000, on modifie le temps d'attente après avoir allumé ou éteint la led. Par exemple:<br />
** en mettant 200 et 200, la led clignote 5 fois plus vite<br />
** en mettant 2000 et 2000, la led clignote 2 fois plus lentement<br />
** en mettant 500 et 1500, la led clignote à la même vitesse, mais est allumée moins longtemps<br />
<br />
Résultat:<br />
* Compréhension d'un premier programme<br />
* Passage immédiat à l'action et interaction immédiate avec le sujet d'étude<br />
<br />
==== Défi 2: SOS morse ====<br />
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.<br />
<br />
Question pratique: faites donc un afficheur de SOS en morse sur la led L !<br />
<br />
Réponses: <br />
* diversité d'approches, de stratégies:<br />
** on peut faire de simples copier coller des 4 lignes de l'exemple de départ<br />
** utiliser des fonctions: créer une fonction flash_court() et une fonction flash-long(), par exemple<br />
* 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;<br />
<br />
Résultat:<br />
* on a désormais un programme un peu plus sophistiqué que le simple clignotement<br />
<br />
<br />
Questions subsidiaires:<br />
* 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"<br />
* 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).<br />
<br />
<br />
TODO: pretty print source code de ces questions subsidiaires<br />
<br />
En conclusion: même sur un exemple simple, bien structurer son programme et anticiper ce à quoi il va pouvoir servir est important.<br />
<br />
=== Allumer des LED avec intensité variable ===<br />
<br />
==== Défi 3: ultra rapide ====<br />
Question: Il se passe quoi si on fait clignoter suuuper vite?<br />
<br />
Là encore: faites le test! Mettez ''delay(100)'', puis ''delay(10)'' et ''delay(1)''.<br />
<br />
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.<br />
<br />
Question: ajuster la vitesse de clignotement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.<br />
<br />
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 !<br />
<br />
Question: ca veut dire quoi, super vite, pour le microcontrôleur?<br />
<br />
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... <br />
<br />
==== Défi 4 : jouer avec les délais ====<br />
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:Initiation:EnFormations:Arduino:Initiation:En2016-09-08T15:16:21Z<p>Clément: Creation de la page pour traduction à la chaine.</p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Formation Arduino: initiation =<br />
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!<br />
<br />
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers Arduino. <br />
<br />
== TODO/meta ==<br />
* 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?<br />
* ajouter shitloads of pictures<br />
* ajouter le module spoileralert pour masquer les réponses...<br />
* schéma frizting<br />
* prettyprint sourcecode...<br />
* couper en n pages (pour les 3 troncs de contenu, les annexes?), voire préparer pour migration vers learn.electrolab.fr<br />
<br />
== Informations pratiques ==<br />
* Durée: 3h voire plus<br />
* Public visé: tous les membres, niveau débutant en programmation/électronique/Arduino<br />
<br />
== Formations liées ==<br />
*Prérequis: aucun, à part savoir lire.<br />
* Idéalement:<br />
** notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
** notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
<br />
* Formations suivantes:<br />
** Mon premier projet Arduino<br />
<br />
== Matériel requis ==<br />
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<br />
<br />
<br />
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.<br />
<br />
Contenu :<br />
* Arduino Nano + cable USB<br />
* breadboard pour prototypage et cables male/male et femelle/femelle<br />
* potentiomètre et bouton poussoir (joystick)<br />
* leds rouge, verte, jaune, blanche, bleue, RGB et résistances 330 ohm<br />
* photorésistance & thermistance + set de résistances adaptées (2x1k, 2x10k, 2x100k)<br />
* micro-servomoteur, buzzer<br />
<br />
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.<br />
<br />
=== Installation IDE ===<br />
A déplacer au bon endroit/page de référence en la matiere:<br />
* voir https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide à traduire<br />
* 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.<br />
<br />
== Ressources additionnelles ==<br />
Pour se fournir en matériel:<br />
* 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<br />
* de nombreuses enseignes vendent du matériel lié à arduino: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== A propos d'Arduino ===<br />
* 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] <br />
* [https://www.arduino.cc/en/Guide/HomePage la page équivalente à celle-ci] directement sur le site official (en moins bien, forcément ;)<br />
* [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<br />
* reference francophone: pas mal de choses bien ici: http://eskimon.fr/<br />
* explorez les sites des vendeurs de matériel type Sparkfun, Adafruit Industries, ...<br />
* ouvrages papier: à mon humble avis, "Arduino pour les nuls" est pas mal.<br />
<br />
=== A propos de la programmation ===<br />
* notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
* voir [https://www.arduino.cc/en/Reference/HomePage les elements du langage de programmation et les librairies Arduino]<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique<br />
* https://fr.wikiversity.org/wiki/Introduction_g%C3%A9n%C3%A9rale_%C3%A0_la_programmation<br />
* https://fr.wikiversity.org/wiki/Introduction_au_langage_C<br />
<br />
=== A propos de l'electronique ===<br />
* notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|sur le wiki du lab]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectromagn%C3%A9tisme_et_%C3%A9lectricit%C3%A9<br />
<br />
= Contenu détaillé =<br />
Cette formation est prevue pour être animée au lab.<br />
Il est envisageable de suivre le plan en autoformation (mais pour l'instant, cette page nécessite d'être étoffée).<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement.<br />
<br />
== Introduction ==<br />
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.<br />
<br />
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 !<br />
<br />
==== Préliminaires: notions d'électronique et d'informatique ====<br />
Pendant cette formation, nous allons manipuler:<br />
* des notions d'électronique :<br />
** électricité, tension/courant<br />
** circuit électrique, schémas et modèle<br />
* des notions d'informatique :<br />
** qu'est-ce que c'est qu'un programme? langage de programmation.<br />
** sémantique du langage et [https://www.arduino.cc/en/Reference/HomePage mots clés spécifiques Arduino].<br />
** étapes de travail: conception, écriture, compilation, tests & correctifs.<br />
<br />
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.<br />
<br />
<br />
=== Microcontrôleurs ===<br />
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<br />
<br />
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<br />
<br />
https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR<br />
<br />
<br />
==== Qu'est-ce qu'un microcontrôleur? ====<br />
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.<br />
<br />
TODO: picture d'un chip au centre d'une carte.<br />
<br />
==== Qu'est-ce qu'un microprocesseur ? ====<br />
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 :<br />
* ajouter la valeur 42 à la case mémoire #3<br />
* si la case mémoire #3 est nulle, aller exécuter l'instruction 2 cases plus bas dans la mémoire programme<br />
* sinon, exécuter celle 1 case plus bas dans la mémoire programme<br />
<br />
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.<br />
<br />
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"...<br />
<br />
==== Qu'est-ce que le binaire et le nombre de bits ? ====<br />
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.<br />
<br />
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.<br />
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 !<br />
<br />
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.<br />
<br />
<br />
Voir:<br />
* https://fr.wikiversity.org/wiki/Code_de_num%C3%A9ration/Introduction<br />
* https://fr.wikipedia.org/wiki/Virgule_fixe<br />
* https://fr.wikipedia.org/wiki/IEEE_754 (norme pour nombres à virgule: attention compliqué!)<br />
<br />
==== A quoi ca sert/où ca sert? ====<br />
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.<br />
<br />
TODO: picture synoptique système d'un objet courant simple, avec visu entrées, sorties, algorithme<br />
<br />
Par exemple: {système quelconque avec asservissement ou FSM, genre controleur de machine à laver? ou d'ascenceur?}<br />
<br />
<br />
==== Comment on s'en sert? ====<br />
* 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?<br />
* 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.<br />
* É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!<br />
* Tests, correctifs & modifications: rien ne marche jamais du premier coup...<br />
<br />
=== L'univers Arduino ===<br />
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!<br />
<br />
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.<br />
<br />
==== C'est quoi Arduino ? ====<br />
Par rapport à plein de cartes qui existaient auparavant, les gens d'Arduino ont fait plusieurs trucs géniaux:<br />
* 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.<br />
* 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.<br />
* 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.<br />
<br />
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.<br />
<br />
==== Anatomie d'une carte Arduino ====<br />
présentation de la Nano: photo, feature sheet.<br />
<br />
Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg image d'une Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png le pinout Arduino Nano]<br />
<br />
==== Fonctionnalités de notre carte Arduino ====<br />
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 :<br />
* 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.<br />
* 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..<br />
* 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).<br />
* 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 !<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Utiliser l'outil logiciel ====<br />
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.<br />
* menus (choix de carte/port, exemples)<br />
* boutons upload & terminal <br />
* fenêtre d'édition du programme<br />
TODO: pictures de partout.<br />
<br />
==== Installation des logiciels ====<br />
'''Installation/verification de l'IDE + du driver.'''<br />
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.<br />
<br />
TODO: pictures de partout.<br />
<br />
* Installation pas à pas de l'IDE<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== Le matériel ===<br />
Nous allons découvrir chacun des éléments du kit de découverte Arduino.<br />
<br />
TODO: pictures de partout ; est-ce qu'on renverrait pas vers des pages ailleurs qui contiennent ces infos?<br />
<br />
*Breadboard <br />
** Décrire comment marche une breadboard<br />
** Mises en garde/comment on fait un circuit<br />
* composant x:<br />
<br />
== Piloter des sorties ==<br />
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.<br />
<br />
=== Allumer et éteindre des LED ===<br />
<br />
==== Exemple "blink" et fonctions de base ====<br />
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.<br />
<br />
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.<br />
<br />
Cette manipulation simple représente le B.A.BA de l'utilisation de microcontrôleurs: bravo, vous venez de faire votre premier pas :)<br />
<br />
<br />
'''Le montage:'''<br />
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 ! <br />
<br />
TODO: pictures.<br />
<br />
'''Comprendre le schéma:'''<br />
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.<br />
<br />
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 !<br />
<br />
TODO: picture schematic sortie arduino resistance led.<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient quatre instructions:<br />
** on allume la led, en mettant la sortie 13 à l'état haut<br />
** on attend 1000 millisecondes, soit une seconde<br />
** on éteint la led, en mettant la sortie 13 à l'état bas<br />
** on attend 1000 millisecondes, soit une seconde<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Défi 1: changer la vitesse de clignottement ====<br />
Question: Comment on fait pour changer la vitesse à laquelle clignote la led ?<br />
<br />
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.<br />
<br />
Réponse: {masqué!}<br />
* en changeant la valeur 1000, on modifie le temps d'attente après avoir allumé ou éteint la led. Par exemple:<br />
** en mettant 200 et 200, la led clignote 5 fois plus vite<br />
** en mettant 2000 et 2000, la led clignote 2 fois plus lentement<br />
** en mettant 500 et 1500, la led clignote à la même vitesse, mais est allumée moins longtemps<br />
<br />
Résultat:<br />
* Compréhension d'un premier programme<br />
* Passage immédiat à l'action et interaction immédiate avec le sujet d'étude<br />
<br />
==== Défi 2: SOS morse ====<br />
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.<br />
<br />
Question pratique: faites donc un afficheur de SOS en morse sur la led L !<br />
<br />
Réponses: <br />
* diversité d'approches, de stratégies:<br />
** on peut faire de simples copier coller des 4 lignes de l'exemple de départ<br />
** utiliser des fonctions: créer une fonction flash_court() et une fonction flash-long(), par exemple<br />
* 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;<br />
<br />
Résultat:<br />
* on a désormais un programme un peu plus sophistiqué que le simple clignotement<br />
<br />
<br />
Questions subsidiaires:<br />
* 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"<br />
* 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).<br />
<br />
<br />
TODO: pretty print source code de ces questions subsidiaires<br />
<br />
En conclusion: même sur un exemple simple, bien structurer son programme et anticiper ce à quoi il va pouvoir servir est important.<br />
<br />
=== Allumer des LED avec intensité variable ===<br />
<br />
==== Défi 3: ultra rapide ====<br />
Question: Il se passe quoi si on fait clignoter suuuper vite?<br />
<br />
Là encore: faites le test! Mettez ''delay(100)'', puis ''delay(10)'' et ''delay(1)''.<br />
<br />
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.<br />
<br />
Question: ajuster la vitesse de clignotement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.<br />
<br />
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 !<br />
<br />
Question: ca veut dire quoi, super vite, pour le microcontrôleur?<br />
<br />
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... <br />
<br />
==== Défi 4 : jouer avec les délais ====<br />
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clémenthttps://wiki.electrolab.fr/FormationsFormations2016-09-06T12:52:41Z<p>Clément: /* Formations orphelines */</p>
<hr />
<div>Cette page rassemble les informations sur tout ce qui concerne les formations à l'Electrolab.<br />
La [[CommissionFormation]] s'occupe de coordonner ces activités. Nous sommes joignables à formations(at)electrolab.fr<br />
<br />
= Les différents types de formations =<br />
Nous distinguons plusieurs types de formations:<br />
* les formations de type initiation et découverte, qui permettent à tous d'aborder chaque domaine d'activité du lab.<br />
* les formations habilitantes, qui donnent accès à certains équipements et/ou zones le nécessitant.<br />
* toutes les autres, qui sont organisées librement par les membres pour présenter un sujet qu'ils maitrisent bien.<br />
* les workshops, qui sont des sessions de partage de connaissances où les membres peuvent venir se rencontrer.<br />
Il arrive par ailleurs que des séminaires et formations payantes soient organisées au lab.<br />
<br />
<br />
Vous pouvez trouvez les informations sur les dates d'organisation :<br />
* [[Planning_formation_2016|Planning de Formation 2016]]<br />
* [[Events-Workshops|Annonce des Events & workshops]]<br />
* [http://blog.electrolab.fr/calendrier-3/ Calendrier de l'Electrolab]<br />
* Inscription à la mailing list : envoyer un mail à electrolab-request(at)electrolab(point)fr avec « subscribe » pour sujet.<br />
<br />
= Initiations et découverte =<br />
Le lab organise de manière récurrente des sessions de découverte sur différents sujets. La plupart de ces formations sont organisées très régulièrement: n'hésitez pas à demander s'il n'y a pas de session de prévue sur un sujet qui vous intéresse !<br />
<br />
== Wiki 101 ==<br />
Formation pour apprendre à utiliser le wiki..<br />
Voici le support de cours, qui peut suffir en lui-même : [[Tuto_Wiki|la page Tuto wiki.]]<br />
<br />
== Notions fondamentales d'électronique ==<br />
Cette formation, en utilisant le prétexte d'ajouter un système d'éclairage sur un vélo, permet de découvrir ce qu'est l'électricité et l'électronique, en se penchant sur les notions fondamentales: <br />
* C'est quoi au juste l'électricité ? Phénomènes physiques sous-jacents.<br />
* Notions de courant, tension ; de continu et d'alternatif ; de circuit et schéma ; Loi d'Ohm et caractéristiques d'un composant.<br />
* Notions requises pour comprendre les schémas usuels: parallèle et série ; lois de Kirshoff (loi des mailles, loi des noeuds) ; puissance et thermique ; diodes et caractéristiques non linéaires<br />
Ceci sans oublier les outils classiques: multimètre, alimentation stabilisée, oscilloscope.<br />
<br />
Cette formation s'adresse à tous, et permet de mieux comprendre les bases de l'électronique pour ensuite aborder tous les projets dans ces domaines.<br />
* Contact: Clément/Grommit<br />
* Prochaine session: à planifier, envoyer un email à core(at)electrolab.fr si intéressé<br />
* Plan détaillé et infos complémentaires: [[Formations:Electronique:Initiation]]<br />
<br />
== Notions fondamentales de programmation ==<br />
Cette formation permet de découvrir ce qu'est la programmation, en s'adressant aux grands débutants:<br />
* C'est quoi un programme? Un ordinateur?<br />
* Découverte très concrète des fondamentaux de l'algorithmique, de la programmation en langage C (Arduino) et/ou Python<br />
* Réalisation d'un petit projet encadré, au choix.<br />
Ceci sans oublier la prise en main des outils classiques pour mener à bien son projet.<br />
<br />
Cette formation s'adresse à tous, et permet de mieux comprendre les bases de la programmation pour ensuite aborder tous les projets utilisant un programme informatique.<br />
* Contact: Clément/Grommit<br />
* Prochaine session: à planifier, envoyer un email à core(at)electrolab.fr si intéressé<br />
* Plan détaillé et infos complémentaires: [[Formations:Programmation:Initiation]]<br />
<br />
== Initiation électronique numérique ==<br />
L'électronique numérique est au cœur de nombreuses choses du quotidien: téléphones portables, ordinateurs, microcontrôleurs et objets "intelligents"... tout cela repose sur divers circuits logiques. Découvrez comment ils fonctionnent.<br />
<br />
TODO: retoucher description.<br />
<br />
En présupposant une connaissance de base de l'électronique, cette formation aborde (A REVOIR) :<br />
* l'électronique numérique comme "astuce" pour traiter l'information.<br />
* La logique combinatoire/séquentielle, les automates: théorie qui se passe d'électronique<br />
* Les circuits intégrés numériques et le silicium: l'implémentation pratique.<br />
* Taxonomie, la conception et la fabrication de circuits, la logique programmable. <br />
<br />
<br />
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers de l'électronique numérique. D'autres formations pour approfondir sont également prévues.<br />
* Contact: Clément/NicoM<br />
* Prochaine session: à planifier, envoyer un email à core(at)electrolab.fr si intéressé<br />
* Plan détaillé et infos complémentaires: [[Formations:FPGA:Initiation]]<br />
<br />
== Initiation VHDL et FPGA ==<br />
{description: langage HDL et FPGA}<br />
<br />
En présupposant une connaissance de base de l'électronique numérique, cette formation aborde:<br />
* {voir contenu formation Nico}<br />
<br />
Notes:<br />
* On utilise des cartes Altera Bemicro MAX10 (le lab en possède)<br />
* Il est très largement préférable d'avoir installé les outils logiciels en amont de la formation si on souhaite les utiliser.<br />
* Le lab dispose de cartes et (bientot) d'ordinateurs préinstallés pour pouvoir suivre cette formation<br />
<br />
Cette formation s'adresse à tous, et permet de passer à la pratique avec les FPGA. D'autres formations pour approfondir sont également prévues.<br />
* Contact: Clément/NicoM<br />
* Prochaine session: à planifier, envoyer un email à core(at)electrolab.fr si intéressé<br />
* Plan détaillé et infos complémentaires: http://wiki.electrolab.fr/Formation::FPGA<br />
<br />
== Découverte d'Arduino et électronique embarquée ==<br />
Arduino, la célèbre carte à microcontrolleur, rend accessible la bidouille électronique dite embarquée: capteurs, actionneurs, code. Découvrez ses capacités (entrées, sorties, communication) en réalisant plusieurs petits defis et montages sympa! Découvrez:<br />
* les sorties (pilotage LED, PWM)<br />
* les entrées (digitales avec un bouton, analogiques avec un potentiometre)<br />
* les communications avec un PC (Arduino->PC et PC->Arduino)<br />
et divers capteurs et actionneurs sympa (capteur de temperature, de lumière, servomoteur de modélisme et buzzer). Le tout avec divers petits defis fun, accessibles à touts!<br />
<br />
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers Arduino. Idéalement, avoir des notions d'électronique (voir initiation).<br />
* Contact: Clément<br />
* Prochaine session: 1/9/2016 (session complète). Une fois par mois environ. Envoyez un email à core(at)electrolab.fr si vous êtes intéressé(es)<br />
* Plan détaillé et infos complémentaires: [[Formations:Arduino:Initiation]]<br />
<br />
== Premier projet à base d'Arduino ==<br />
Grâce aux cartes Arduino, il est possible d'aborder tout un tas de projets passionnants! Plus simple à dire qu'à faire tout seul dans son coin... heureusement, le lab est là pour pouvoir se lancer dans de bonnes conditions.<br />
<br />
Cette formation s'adresse à toute personne voulant se lancer dans un projet Arduino, avec un petit coup de main.<br />
* Contact: Clément<br />
* Prochaine session: A planifier: envoyer un email à core(at)electrolab.fr si intéressé<br />
* Plan détaillé et infos complémentaires: [[Formations:Arduino:PremierProjet]]<br />
<br />
== Fabrication de circuits imprimés ==<br />
Savoir fabriquer des circuits imprimés permet de realiser plein de projets en électronique! Ca tombe bien, le lab est pas mal équipé pour cela.<br />
<br />
Cette formation de prise en main des moyens de fabrication de prototypes de PCB au lab a pour but de vous rendre autonome sur le sujet.<br />
* Contact: Clément<br />
* Prochaine session: A planifier: envoyer un email à core(at)electrolab.fr si intéressé<br />
* Plan détaillé et infos complémentaires: [[Formations:PCB:Initiation]]<br />
<br />
== Notions de MAO sous Linux ==<br />
Deux ateliers sont proposés:<br />
* Une initiation à [https://lmms.io LMMS] (Linux MultiMedia Studio) - durée: 2 heures*<br />
* Introduction à la musique assistée par ordinateur sous Linux - durée 4 heures :<br />
** Le son sous Linux<br />
** Installation des outils<br />
** Configuration et utilisations de base<br />
*** Utilisation d'un séquenceur ([http://sourceforge.net/projects/tuxguitar/ tuxguitar])<br />
*** Utilisation d'un simulateur d'ampli ([http://guitarix.org/ guitarix])<br />
*** Utilisation de synthétiseurs ([https://github.com/amsynth/amsynth amsynth])<br />
*** Utilisation d'un séquenceur de batterie ([http://www.hydrogen-music.org/hcms/ hydrogen])<br />
*** Enregistrement multipistes avec [http://qtractor.sourceforge.net/qtractor-index.html qtractor]<br />
<br />
Des informations relatives à cet atelier sont disponibles sur ce [http://ycollette.free.fr/pmwiki/pmwiki.php?n=PmWiki.LesCuizines site].<br />
* Contact: Yann<br />
* Prochaine session: A planifier: envoyer un email à core(at)electrolab.fr si intéressé<br />
* Plan détaillé et infos complémentaires: <br />
** Pour la formation MAO: [http://ycollette.free.fr/pmwiki/pmwiki.php?n=PmWiki.LesCuizines Atelier MAO]<br />
** Pour la formation LMMS: [http://ycollette.free.fr/pmwiki/pmwiki.php?n=PmWiki.AtelierLMMS Atelier LMMS]<br />
<br />
== Découverte Impression 3D ==<br />
Découvrez les différents aspects de l'impression 3D:<br />
* Différents procédés & capacites offertes par l'impression 3D<br />
* Méthode de travail (workflow, en anglais)<br />
* Anatomie d'une imprimante 3D<br />
* Passage à la pratique avec une machine du lab.<br />
<br />
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers de l'impression 3D<br />
* Contact: Vincent<br />
* Prochaine session: à planifier, envoyer un email à core(at)electrolab.fr si intéressé<br />
* Plan détaillé et infos complémentaires: [[Formations:Impression3D:Initiation]]<br />
<br />
== Initiation à la CAO mécanique avec FreeCAD ==<br />
Faites vos premiers pas avec l'outil libre FreeCAD, qui vous permettra de concevoir vos pieces à imprimer en 3D, ou, le cas échéant, à usiner.<br />
Apprenez à:<br />
* faire une esquisse puis un volume<br />
* realiser un profil: maitrise des contraintes, de l'inferface, ...<br />
* ajouter des trous: gérer plusieurs pieces<br />
* Génération de pieces par rotation de profil<br />
Le tout en utilisant en direct le logiciel.<br />
<br />
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers de la CAO mécanique.<br />
* Contact: Alexandre L.<br />
* Prochaine session: à planifier, envoyer un email à core(at)electrolab.fr si intéressé<br />
* Plan détaillé et infos complémentaires: [[Formations:FreeCAD:Initiation]]<br />
<br />
<br />
<br />
== Usinage petite CNC ==<br />
{description de la formation: charly robot & big charly, usinages simples, workflow}<br />
<br />
Sans prérequis particulier, cette formation aborde:<br />
* topic1<br />
* topic2<br />
* topic3<br />
<br />
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers de l'usinage avec une machine à commande numérique.<br />
* Contact: Clément/Colin<br />
* Prochaine session: à planifier, envoyer un email à core(at)electrolab.fr si intéressé<br />
* Plan détaillé et infos complémentaires: [[Formations:CNC:Initiation]]<br />
<br />
== Découpe laser ==<br />
{description de la formation: lasercutter, workflow}<br />
<br />
Sans prérequis particulier, cette formation aborde:<br />
* topic1<br />
* topic2<br />
* topic3<br />
<br />
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers de la découpe laser.<br />
* Contact: core<br />
* Prochaine session: à planifier, envoyer un email à core(at)electrolab.fr si intéressé<br />
* Plan détaillé et infos complémentaires: [[Formations:Laser:Initiation]]<br />
<br />
== Initiation soudure électronique : assemblage et fabrication de cartes ==<br />
Cette formation permet de découvrir la soudure électronique, en s'adressant aux grands débutants:<br />
* Constitution d'une carte électronique: circuit imprimé, composants, soudures.<br />
* Le fer à souder et l'alliage de brasure, soudure de composants traversants.<br />
* Fer à air chaud et soudure des composants de surface (CMS/SMD)<br />
Ceci sans oublier le passage à la pratique sur un bout de projet.<br />
<br />
Cette formation s'adresse à tous, et permet de découvrir comment assembler à la main vos propres cartes électroniques (kits ou conceptions perso).<br />
* Contact: Clément/Yannick<br />
* Prochaine session: à planifier, envoyer un email à core(at)electrolab.fr si intéressé<br />
* Plan détaillé et infos complémentaires: [[Formations:Electronique:Soudure:Initiation]]<br />
<br />
== Initiation couture et broderie : savoir se servir des machines à coudre et à broder ==<br />
Cette formation permet de découvrir la couture, la broderie, la conception d'objets textiles, en s'adressant aux grands débutants:<br />
* Conception et réalisation d'un objet textile (tout ou partie): vêtement, accessoire, etc. Savoir dessiner un patron, couper le tissu, assembler, coudre à la machine.<br />
* Broder des dessins sur un support (textile ou autre) à la machine.<br />
Ceci sans oublier le passage à la pratique sur un bout de projet.<br />
* Animateurs: 3dsman, Silvia.<br />
* Les ateliers qui ont déjà eu lieu:<br />
http://wiki.electrolab.fr/Workshop:CoutureInitiationBouillotte<br />
* Les prochains ateliers:<br />
dimanche 26 juin de 15h à 17h en zone convi.v1 : coudre des leds sur un t-shirt<br />
Pour s'inscrire, c'est ici: https://framadate.org/IVoG8zLAFKnwg3Hk<br />
<br />
= Formations orphelines =<br />
Ces formations n'ont pas d'animateur pour l'instant: manifestez vous si vous voulez participer à leur mise en place ! <br />
<br />
* Notions fondamentales de mécanique et d'usinage: préliminaire aux habilitations machine meca heavy(CNC & conventionnelles)<br />
* Notions fondamentales de CAO pour la mécanique & CNC: préliminaire aux habilitations machine meca heavy (CNC)<br />
<br />
<br />
* ISN pour tous : http://www.education.gouv.fr/pid25535/bulletin_officiel.html?cid_bo=57572 ; est-ce qu'on fait en plusieurs "notions fondamentales"?<br />
<br />
* Travail collaboratif avec GIT<br />
** "Getting Started With GitHub and KiCad (Hardware)" par Contextual Electronics => https://www.youtube.com/watch?v=q3YTxSBxGmg voir aussi https://contextualelectronics.com/learning/getting-started-with-github-and-kicad-hardware<br />
** "Using GitHub Libraries with KiCad " par Contextual Electronics => https://www.youtube.com/watch?v=KNXB4zgupG4<br />
<br />
* Schématique et routage avec Kicad (et/ou Eagle) => GRX?<br />
** "Introduction and KiCad Project Creation - "Getting To Blinky" KiCad Tutorial - Part 1" par Contextual Electronics, série en plusieurs partie, petit projet avec KiCad => https://www.youtube.com/watch?v=iTyi3RvNoB0&list=PLy2022BX6EsrSzOcmuhV9A3bnEY3KSZOO&index=4<br />
<br />
* Initiation au modelage 3D (Blender, Openscade, ...) => 3DS?<br />
<br />
* Initiation couture/textile => Sylvia? 3DS?<br />
* Initiation fonderie => Jordi<br />
<br />
* Initiation soudage arc/TIG<br />
* Notions/Initiation travail du metal => cycle complet genre CAP chaudronnerie condensé<br />
** conception:<br />
*** lecture/étude et mise plan<br />
*** CAO: outils<br />
*** dimensionnement<br />
*** "design for manufacturing": planification projet<br />
** préparatifs/vie d'atelier<br />
*** EPI, sécurité, etc<br />
*** types et choix de matière<br />
*** débit et mise en forme<br />
*** outils: scie radiale ? meuleuse, torche plasma, pliage tôle, pliage tubes, etc...<br />
** usinage<br />
*** tournage simple manuel<br />
*** fraisage simple manuel<br />
** assemblage<br />
*** soudage arc<br />
*** soudage TIG<br />
** mise en pratique: petit(s) projet(s) et réalisation support..<br />
*** a définir!<br />
<br />
* C'est quoi, internet? => tux boys? FDN?<br />
** fondements: historique?, TCP/IP packets vs link cuivre, couches réseaux OSI, Aspects tech (DNS, URL) et reglementaires (icann, IETF, RIPE...), topologie/physique (eg rien de virtuel!), le fameux cloud.<br />
** acteurs (intermédiaires): logiques client/serveur, pair à pair, fournisseur d'accès/de service, minitel 2.0 ; questions bizbiz, entreprises, gouvernements.<br />
** apps&protocoles: html, mail, ftp, 2.0 ; langages? frameworks?<br />
** outils: browser... et quels autres fondamentaux?<br />
** encore plus en vrac:<br />
***Firewall, proxies: localisation (& restrictions)<br />
*** netflix vs comcast case & net neutrality<br />
*** NAT, DHCP<br />
*** ipv4 ipv6, MAC address<br />
*** Ethernet, wifi ; internet while on 3g/4g systems, while in ${PaysPasCoolQuiCensure}; Spoofing/man in the middle?<br />
*** title: "watch and admire what happens downto the electrons' level when you watch a cat video on the Internet" cf https://xkcd.com/676/, en faire une extension/suite<br />
<br />
<br />
D'autre part, s'il vous semble que d'autres sujets devraient être régulièrement abordés au lab, n'hésitez pas à venir en causer avec nous, ou directement à les lister ci dessous:<br />
* Ma formation géniale que je pense pouvoir proposer<br />
* La formation géniale que j'aimerais voir de facon récurente au lab<br />
<br />
= Habilitations et formations sécurité =<br />
<br />
Le lab propose à ses membres des formations de base afin qu'ils puissent évoluer dans le lab et réaliser leurs projets en toute sécurité :<br />
<br />
== Accueil des nouveaux membres ==<br />
TODO: merge formation sécurité ; intégration d'une activité fun genre micro projet multithématique: formation accueil nouveau membre à refondre en un bidule sur 4h avec présentation lab (sécurité, fonctionnement, projets, ...) et activité de groupe fun qui fait mettre les mains dans le cambouis/soude les équipes.<br />
<br />
Découvrez les différents aspects du fonctionnement de l'Electrolab, et posez toutes les questions qui vous passent par la tête !<br />
<br />
Formation indispensable pour tous les nouveaux membres souhaitant s'intégrer au mieux dans notre communauté !<br />
<br />
*Contact: core<br />
*Prochaine session: début décembre, envoyez un mail à formations(at)electrolab.fr si intéressé<br />
*Plan détaillé et infos complémentaires: [[Formations:AccueilMembres]]<br />
**Présentation du lab, de ses différentes zone<br />
**Présentation du fonctionnenement bureau et commissions<br />
**Présentation des outils du lab<br />
**Projets Electrolab et projets soutenus par le lab<br />
**Events<br />
<br />
== Habilitation bases de la sécurité à l'Électrolab ==<br />
TODO: à grouper avec la formation accueil des nouveaux membres.<br />
<br />
<br />
Formation obligatoire pour tous les membres permettant à chacun de bien appréhender la sécurité au lab<br />
<br />
*Contact: core<br />
*Prochaine session: pas prévue pour l'instant :(<br />
<br />
*Plan détaillé et infos complémentaires: [[Formations:Securite]]<br />
**Différentes zones du lab et règles d'accès<br />
**Principaux risques au lab<br />
**Rappel sur la procédure en cas d'accident<br />
**Programme de formations habilitantes<br />
**Procédures en cas d'incendie<br />
**AFPS et correspondants sécurité<br />
<br />
== Habilitation zones ==<br />
L'accès à certaines zones présentant des risques pour les personnes ou les matériels est conditionnée à l'obtention préalable d'une habilitation "zone". Celles-ci sont obtenues à l'issue de formations spécifiques. Elles sont strictement personnelles, et révocables sans appel par les responsables de l'association.<br />
<br />
Toute demande d'habilitation est à adresser aux responsables de zone, et ultimement aux responsables de l'association.<br />
<br />
Les zones à acces restreint sont les suivantes:<br />
* "meca heavy": introduction ; règles de sécurité de base, donne accès à la zone<br />
* "chimie": introduction ; règles de sécurité de base, donne accès à la zone<br />
<br />
<br />
Autres zones à considérer/futures:<br />
* advanced electronics<br />
* fondrie<br />
* bois<br />
* traitement de surface<br />
* metrologie<br />
<br />
== Habilitations équipement ==<br />
L'utilisation de certains équipements ou techniques présentant des risques pour les personnes ou les matériels est conditionnée à l'obtention préalable d'une habilitation "équipement". Celles-ci sont obtenues à l'issue de formations spécifiques. Elles sont strictement personnelles, et révocables sans appel par les responsables de l'association.<br />
<br />
Toute demande d'habilitation est à adresser aux responsables de zone, et ultimement aux responsables de l'association.<br />
<br />
Liste non exhaustive, à préciser...<br />
* Habilitation "petite" CNC (Charlyrobot, big Charlyrobot)<br />
* Habilitation tournage metal conventionnel (Famot)<br />
* Habilitation tournage metal CNC (Cazeneuve) <br />
* Habilitation fraiseuse mécanicien conventionnel (Dufour)<br />
* Habilitation fraisage CNC (TOS)<br />
* Habilitation découpe laser<br />
* MEB<br />
* habilitations travail du metal, à préciser: soudure TIG, acétylène, arc ; machine de soudure par point ; découpe (cisaille tole), sciage (scie ruban), meulage, affûtage, pliage, encochage et estampage ; découpe plasma?<br />
* habilitation électronique avancée spécifiques (HT/electrotech) : à préciser<br />
* ...<br />
<br />
Questions meta:<br />
* à ranger par zone?<br />
* est-ce qu'on sépare les découverte/initiations, avec gestes de base, des habilitations?<br />
* comment gérer la pénurie actuelle de formateurs/habilitants?<br />
<br />
= Autres formations =<br />
Les listes de formations ci dessus correspondent à des activités régulièrement planifiées, et supervisées par l'association. Tous les membres sont par ailleurs encouragés à organiser librement des formations sur les sujets de leur choix. Par exemple:<br />
* Python<br />
* Antennes<br />
* [[Workshop:AppInventorInitiation|Initiation à AppInventor]]<br />
<br />
= Organisation des formations =<br />
<br />
== S'inscrire ==<br />
Selon le type de formation, l'inscription peut avoir lieu de différente manière. Voir le [http://blog.electrolab.fr/calendrier-3/ calendrier] des formations pour plus d'information.<br />
<br />
Souvent un lien vers un Framapad (outils de sondage similaire à Doodle) est diffusé via la ML pour récupérer les inscriptions. Si une formation vous intéresse et que vous n'avez pas le lien, adressez-vous à la [[CommissionFormations|commission formation]].<br />
<br />
<br />
L'immense majorité des formations est réservée aux membres à jour de cotisation. Pas de panique: vous pourrez vous mettre à jour voire vous inscrire le jour J !<br />
<br />
<br />
Par respect pour le ou les formateurs et les autres inscrits:<br />
* on ne se pointe pas en retard<br />
* en cas d'empêchement de dernière minute, on prévient.<br />
<br />
== Organiser une formation ==<br />
Tous les membres sont encouragés à participer à l'organisation de formations. Vous pouvez vous rapprocher de la commission formation pour plus d'infos.<br />
<br />
== Mise à disposition de salle ==<br />
Le lab dispose de plusieurs espaces adaptés pour faire des formations. Il est tout à fait possible d'organiser vos propres formations de manière relativement libre, en vous adressant à un membre du CA.<br />
<br />
=== Salle ===<br />
La salle de formation se trouve à l'entrée de l'Electrolab sur la droite.<br />
<br />
La réservation de la salle se fait auprès de Coline.<br />
<br />
La capacité de la salle est de 9 / 10 personnes pour des formations avec ordinateur.<br />
<br />
La salle dispose :<br />
* De 5 tables, 1 pour le formateur, 4 de deux personnes pour les étudiants<br />
* D'un écran de projection <br />
* D'un vidéo projecteur<br />
* D'un tableau blanc avec marqueurs et brosse<br />
* D'ordinateurs de formation portables<br />
<br />
En sortant de la salle, le formateur ou l'organisateur doit penser :<br />
* Demander aux participants de ranger leur chaise.<br />
* Effacer le tableau.<br />
* Remonter l'écran de projection<br />
* Eteindre les lumières. ;-) merci<br />
<br />
=== Ecran de projection ===<br />
L'écran de projection se trouve sur la gauche du tableau blanc, il se manoeuvre par les boutons en entrant à gauche.<br />
<br />
=== Vidéo projecteur ===<br />
TODO : référence du video projecteur avec notamment la résolution écran supportée<br />
<br />
Résolutions vidéo :<br />
* ...<br />
* ...<br />
<br />
Entrées vidéo :<br />
* ...<br />
* VGA<br />
* Thunderbolt / Mini-display port (Adaptateur à demander à Coline)<br />
<br />
== Ordinateurs de formation ==<br />
La salle de formation dispose de 3 ordinateurs portables par ordre de puissance décroissante :<br />
<br />
* Dell Inspiron 640m<br />
* Dell Latitude D630 Model PPL18<br />
* Dell Latitude D620 Model PPL18<br />
<br />
=== Dell Inspiron 640m ===<br />
* Bios Current version A05 (Last Version A10)<br />
* Intel Core2 Duo T7200 @ 2.00GHz (64-bit PassMark 1181)<br />
* 2GB DDR2 667mhz Dual Channel<br />
* Carte graphique : Intel 945GM <br />
* Ecran 14" WXGA+ (1440 x 900 resolution)<br />
* Wifi : Wi-Fi 802.11a/g ???<br />
* HDD : 120GB<br />
* Alimentation : 65W<br />
<br />
=== Dell Latitude D630 Model PPL18 ===<br />
* Bios Current version A13 (Last Version A19)<br />
* Intel Core2 Duo T7250 @ 2.00GHz (64-bit PassMark 1119)<br />
* 2GB DDR2 667mhz Dual Channel<br />
* Carte graphique : NVIDIA® Quadro NVS 135M<br />
* Ecran 14" : WXGA+ (1440 x 900 resolution)<br />
* Wifi : Wifi Dell Wireless 1390 (802.11g)<br />
* HDD : 120GB<br />
* Alimentation : 65W<br />
<br />
=== Dell Latitude D620 Model PPL18 ===<br />
* Bios Current version A02 (Last Version A10)<br />
* Intel Core Duo T2500 @ 2.00GHz (32-bit PassMark 875)<br />
* 2GB DDR2 667mhz Dual Channel<br />
* Carte graphique : NVIDIA® Quadro NVS 110M<br />
* Ecran 14" WXGA (1200 x 800 resolution)<br />
* Wifi : Intel® PRO/Wireless 3945A/G (802.11a/g)<br />
* HDD : 0 absent<br />
* Alimentation : 65W<br />
<br />
TBC : MorpheusDev<br />
<br />
== Demande de formation ==<br />
Si vous aimeriez découvrir ou approfondir un sujet donné, mais que vous ne trouvez pas votre bonheur dans cette page, il est temps de sonder la communauté, ou de vous adresser à la commission formation.</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:InitiationFormations:Arduino:Initiation2016-09-06T12:47:48Z<p>Clément: /* A propos de l'electronique */</p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Formation Arduino: initiation =<br />
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!<br />
<br />
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers Arduino. <br />
<br />
== TODO/meta ==<br />
* 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?<br />
* ajouter shitloads of pictures<br />
* ajouter le module spoileralert pour masquer les réponses...<br />
* schéma frizting<br />
* prettyprint sourcecode...<br />
* couper en n pages (pour les 3 troncs de contenu, les annexes?), voire préparer pour migration vers learn.electrolab.fr<br />
<br />
== Informations pratiques ==<br />
* Durée: 3h voire plus<br />
* Public visé: tous les membres, niveau débutant en programmation/électronique/Arduino<br />
<br />
== Formations liées ==<br />
*Prérequis: aucun, à part savoir lire.<br />
* Idéalement:<br />
** notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
** notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
<br />
* Formations suivantes:<br />
** Mon premier projet Arduino<br />
<br />
== Matériel requis ==<br />
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<br />
<br />
<br />
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.<br />
<br />
Contenu :<br />
* Arduino Nano + cable USB<br />
* breadboard pour prototypage et cables male/male et femelle/femelle<br />
* potentiomètre et bouton poussoir (joystick)<br />
* leds rouge, verte, jaune, blanche, bleue, RGB et résistances 330 ohm<br />
* photorésistance & thermistance + set de résistances adaptées (2x1k, 2x10k, 2x100k)<br />
* micro-servomoteur, buzzer<br />
<br />
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.<br />
<br />
=== Installation IDE ===<br />
A déplacer au bon endroit/page de référence en la matiere:<br />
* voir https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide à traduire<br />
* 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.<br />
<br />
== Ressources additionnelles ==<br />
Pour se fournir en matériel:<br />
* 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<br />
* de nombreuses enseignes vendent du matériel lié à arduino: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== A propos d'Arduino ===<br />
* 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] <br />
* [https://www.arduino.cc/en/Guide/HomePage la page équivalente à celle-ci] directement sur le site official (en moins bien, forcément ;)<br />
* [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<br />
* reference francophone: pas mal de choses bien ici: http://eskimon.fr/<br />
* explorez les sites des vendeurs de matériel type Sparkfun, Adafruit Industries, ...<br />
* ouvrages papier: à mon humble avis, "Arduino pour les nuls" est pas mal.<br />
<br />
=== A propos de la programmation ===<br />
* notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
* voir [https://www.arduino.cc/en/Reference/HomePage les elements du langage de programmation et les librairies Arduino]<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique<br />
* https://fr.wikiversity.org/wiki/Introduction_g%C3%A9n%C3%A9rale_%C3%A0_la_programmation<br />
* https://fr.wikiversity.org/wiki/Introduction_au_langage_C<br />
<br />
=== A propos de l'electronique ===<br />
* notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|sur le wiki du lab]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectromagn%C3%A9tisme_et_%C3%A9lectricit%C3%A9<br />
<br />
= Contenu détaillé =<br />
Cette formation est prevue pour être animée au lab.<br />
Il est envisageable de suivre le plan en autoformation (mais pour l'instant, cette page nécessite d'être étoffée).<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement.<br />
<br />
== Introduction ==<br />
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.<br />
<br />
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 !<br />
<br />
==== Préliminaires: notions d'électronique et d'informatique ====<br />
Pendant cette formation, nous allons manipuler:<br />
* des notions d'électronique :<br />
** électricité, tension/courant<br />
** circuit électrique, schémas et modèle<br />
* des notions d'informatique :<br />
** qu'est-ce que c'est qu'un programme? langage de programmation.<br />
** sémantique du langage et [https://www.arduino.cc/en/Reference/HomePage mots clés spécifiques Arduino].<br />
** étapes de travail: conception, écriture, compilation, tests & correctifs.<br />
<br />
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.<br />
<br />
<br />
=== Microcontrôleurs ===<br />
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<br />
<br />
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<br />
<br />
https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR<br />
<br />
<br />
==== Qu'est-ce qu'un microcontrôleur? ====<br />
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.<br />
<br />
TODO: picture d'un chip au centre d'une carte.<br />
<br />
==== Qu'est-ce qu'un microprocesseur ? ====<br />
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 :<br />
* ajouter la valeur 42 à la case mémoire #3<br />
* si la case mémoire #3 est nulle, aller exécuter l'instruction 2 cases plus bas dans la mémoire programme<br />
* sinon, exécuter celle 1 case plus bas dans la mémoire programme<br />
<br />
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.<br />
<br />
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"...<br />
<br />
==== Qu'est-ce que le binaire et le nombre de bits ? ====<br />
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.<br />
<br />
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.<br />
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 !<br />
<br />
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.<br />
<br />
<br />
Voir:<br />
* https://fr.wikiversity.org/wiki/Code_de_num%C3%A9ration/Introduction<br />
* https://fr.wikipedia.org/wiki/Virgule_fixe<br />
* https://fr.wikipedia.org/wiki/IEEE_754 (norme pour nombres à virgule: attention compliqué!)<br />
<br />
==== A quoi ca sert/où ca sert? ====<br />
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.<br />
<br />
TODO: picture synoptique système d'un objet courant simple, avec visu entrées, sorties, algorithme<br />
<br />
Par exemple: {système quelconque avec asservissement ou FSM, genre controleur de machine à laver? ou d'ascenceur?}<br />
<br />
<br />
==== Comment on s'en sert? ====<br />
* 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?<br />
* 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.<br />
* É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!<br />
* Tests, correctifs & modifications: rien ne marche jamais du premier coup...<br />
<br />
=== L'univers Arduino ===<br />
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!<br />
<br />
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.<br />
<br />
==== C'est quoi Arduino ? ====<br />
Par rapport à plein de cartes qui existaient auparavant, les gens d'Arduino ont fait plusieurs trucs géniaux:<br />
* 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.<br />
* 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.<br />
* 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.<br />
<br />
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.<br />
<br />
==== Anatomie d'une carte Arduino ====<br />
présentation de la Nano: photo, feature sheet.<br />
<br />
Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg image d'une Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png le pinout Arduino Nano]<br />
<br />
==== Fonctionnalités de notre carte Arduino ====<br />
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 :<br />
* 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.<br />
* 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..<br />
* 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).<br />
* 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 !<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Utiliser l'outil logiciel ====<br />
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.<br />
* menus (choix de carte/port, exemples)<br />
* boutons upload & terminal <br />
* fenêtre d'édition du programme<br />
TODO: pictures de partout.<br />
<br />
==== Installation des logiciels ====<br />
'''Installation/verification de l'IDE + du driver.'''<br />
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.<br />
<br />
TODO: pictures de partout.<br />
<br />
* Installation pas à pas de l'IDE<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== Le matériel ===<br />
Nous allons découvrir chacun des éléments du kit de découverte Arduino.<br />
<br />
TODO: pictures de partout ; est-ce qu'on renverrait pas vers des pages ailleurs qui contiennent ces infos?<br />
<br />
*Breadboard <br />
** Décrire comment marche une breadboard<br />
** Mises en garde/comment on fait un circuit<br />
* composant x:<br />
<br />
== Piloter des sorties ==<br />
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.<br />
<br />
=== Allumer et éteindre des LED ===<br />
<br />
==== Exemple "blink" et fonctions de base ====<br />
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.<br />
<br />
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.<br />
<br />
Cette manipulation simple représente le B.A.BA de l'utilisation de microcontrôleurs: bravo, vous venez de faire votre premier pas :)<br />
<br />
<br />
'''Le montage:'''<br />
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 ! <br />
<br />
TODO: pictures.<br />
<br />
'''Comprendre le schéma:'''<br />
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.<br />
<br />
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 !<br />
<br />
TODO: picture schematic sortie arduino resistance led.<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient quatre instructions:<br />
** on allume la led, en mettant la sortie 13 à l'état haut<br />
** on attend 1000 millisecondes, soit une seconde<br />
** on éteint la led, en mettant la sortie 13 à l'état bas<br />
** on attend 1000 millisecondes, soit une seconde<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Défi 1: changer la vitesse de clignottement ====<br />
Question: Comment on fait pour changer la vitesse à laquelle clignote la led ?<br />
<br />
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.<br />
<br />
Réponse: {masqué!}<br />
* en changeant la valeur 1000, on modifie le temps d'attente après avoir allumé ou éteint la led. Par exemple:<br />
** en mettant 200 et 200, la led clignote 5 fois plus vite<br />
** en mettant 2000 et 2000, la led clignote 2 fois plus lentement<br />
** en mettant 500 et 1500, la led clignote à la même vitesse, mais est allumée moins longtemps<br />
<br />
Résultat:<br />
* Compréhension d'un premier programme<br />
* Passage immédiat à l'action et interaction immédiate avec le sujet d'étude<br />
<br />
==== Défi 2: SOS morse ====<br />
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.<br />
<br />
Question pratique: faites donc un afficheur de SOS en morse sur la led L !<br />
<br />
Réponses: <br />
* diversité d'approches, de stratégies:<br />
** on peut faire de simples copier coller des 4 lignes de l'exemple de départ<br />
** utiliser des fonctions: créer une fonction flash_court() et une fonction flash-long(), par exemple<br />
* 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;<br />
<br />
Résultat:<br />
* on a désormais un programme un peu plus sophistiqué que le simple clignotement<br />
<br />
<br />
Questions subsidiaires:<br />
* 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"<br />
* 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).<br />
<br />
<br />
TODO: pretty print source code de ces questions subsidiaires<br />
<br />
En conclusion: même sur un exemple simple, bien structurer son programme et anticiper ce à quoi il va pouvoir servir est important.<br />
<br />
=== Allumer des LED avec intensité variable ===<br />
<br />
==== Défi 3: ultra rapide ====<br />
Question: Il se passe quoi si on fait clignoter suuuper vite?<br />
<br />
Là encore: faites le test! Mettez ''delay(100)'', puis ''delay(10)'' et ''delay(1)''.<br />
<br />
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.<br />
<br />
Question: ajuster la vitesse de clignotement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.<br />
<br />
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 !<br />
<br />
Question: ca veut dire quoi, super vite, pour le microcontrôleur?<br />
<br />
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... <br />
<br />
==== Défi 4 : jouer avec les délais ====<br />
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clémenthttps://wiki.electrolab.fr/Formations:Electronique:InitiationFormations:Electronique:Initiation2016-09-06T12:46:32Z<p>Clément: /* Ressources additionnelles */</p>
<hr />
<div> Page en cours de creation...<br />
= Notions fondamentales d'électronique =<br />
Cette formation, en utilisant le prétexte d'ajouter un système d'éclairage sur un vélo, permet de découvrir ce qu'est l'électricité et l'électronique, en se penchant sur les notions fondamentales. Les outils indispensables sont également abordés.<br />
<br />
<br />
== Informations pratiques ==<br />
* Durée: 4h <br />
* Public visé: tous les membres souhaitant mieux comprendre ces notions fondamentales<br />
<br />
== Formations liées ==<br />
* Prérequis: culture générale<br />
* Formations suivantes: un grand nombre de possibilités offertes!<br />
<br />
== Matériel requis ==<br />
Ce que nous allons utiliser pour la partie mise en pratique: <br />
* bidules liés à l'éclairage vélo: câbles, boite pile, leds (blanches, rouges, oranges), résistances, interrupteurs, pièces mécaniques pour montage des éléments sur le vélo.<br />
* éventuellement, plaquette d'essai si on veut tester avec de vraies résistances, interrupteurs... sans passer par le projet vélo<br />
* multimètre, alimentation stable<br />
<br />
<br />
A noter que le lab dispose de tout le matériel nécessaire. Si vous voulez équiper votre propre vélo à l'issu de la formation, vous trouverez tous les éléments requis au lab, sous forme de kit.<br />
<br />
== Ressources additionnelles ==<br />
Supports externes/doc (à creuser/faire du ménage) :<br />
* ajouter liens pertinents, notamment... wikipedia.<br />
* https://wiki.analog.com/university/courses/electronics/text/electronics-toc<br />
* des trucs marrants ici:https://www.youtube.com/playlist?list=PL2EB473ED87C5561D<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectromagn%C3%A9tisme_et_%C3%A9lectricit%C3%A9<br />
<br />
= Contenu détaillé =<br />
Cette formation est prévue pour être animée au lab. Il est envisageable de suivre le plan en autoformation.<br />
<br />
Le slide-pack est en cours de création et sera mis à disposition ici ultérieurement.<br />
<br />
Il est prévu que les parties "théoriques" (en particulier le 1er chapitre) soit lu au calme avant la séance, et que la session de formation soit réservée aux questions et manipulations pratiques.<br />
<br />
== Introduction ==<br />
Cette formation a pour objectif de rendre l'électricité et les concepts associés compréhensibles et utilisables.<br />
<br />
<br />
Le déroulé est le suivant:<br />
* C'est quoi au juste l'électricité ?<br />
** historique de sa découverte, et phénomènes physiques<br />
** la théorie: charge électrique et électromagnétisme<br />
** quel intérêt? quels usages?<br />
<br />
* Notions fondamentales:<br />
** courant/tension<br />
** circuit électrique, composants et schéma<br />
** caractéristique d'un composant et loi d'Ohm<br />
** outils: multimètre et alimentation stabilisée<br />
<br />
* Schémas usuels:<br />
** montage parallèle et série<br />
** lois de Kirshoff (loi des mailles, loi des nœuds)<br />
** pont diviseur de tension?<br />
** aspects puissance, thermique, énergie et ordres de grandeurs<br />
** diodes et caractéristiques non linéaires<br />
<br />
Pour la partie mise en pratique, on va concevoir (et potentiellement réaliser) un système d'éclairage de vélo : phares et veilleuse, allumage feux arrières lors de freinages. Les clignotants sont un peu au delà de ce qu'on saura faire à la fin, mais de pas grand chose.<br />
<br />
<br />
=== Pourquoi cette formation ===<br />
L'électricité et par extension l'électronique sont omniprésentes aujourd'hui. En particulier, une majorité de projets au lab nécessitent une forme de compréhension de ces notions. Même si à peu près tout le monde sait vaguement de quoi on parle, il n'est pas facile d'aborder avec précision ces sujets, tout en restant accessible à tous.<br />
<br />
<br />
== Chapitre 1 : C'est quoi l'électricité ? ==<br />
En utilisant l'angle des phénomènes physiques associés puis de la théorie la plus stricte, on va tenter de mieux comprendre ce qu'est l'électricité, comment elle se comporte et à quoi elle peut servir:<br />
* historique, et comment on l'observe<br />
* en théorie, c'est quoi<br />
* quel intérêt? quels usages?<br />
<br />
<br />
=== Phénomènes physiques observables et tâtonnements historiques ===<br />
Approche historique pour présenter les choses, c'est à dire comment on a découvert l’électricité & les atomes. Les phénomènes physiques observables: <br />
* éclairs<br />
* électricité statique<br />
* électromagnétisme<br />
* réactions chimiques<br />
<br />
=== La théorie ===<br />
Après de nombreux tâtonnements historiques, reprenons à la base, en fonction de l'état actuel des connaissances: l'électricité, c'est le déplacement de charges.<br />
* notion fondamentale de charge électrique : https://fr.wikipedia.org/wiki/Charge_%C3%A9lectrique<br />
* potentiel électrique: https://fr.wikipedia.org/wiki/Potentiel_%C3%A9lectrique<br />
* particule vecteur de charge la plus connue: l'électron. https://fr.wikipedia.org/wiki/%C3%89lectron Rapports avec la structure atomique. Autres vecteurs de charge: les ions.<br />
* Au final, l'étude de tout cela forme la branche de la physique qu'on appelle électromagnétisme: https://fr.wikipedia.org/wiki/%C3%89lectromagn%C3%A9tisme ; champ et force électrique: https://fr.wikipedia.org/wiki/Champ_%C3%A9lectrique champ et force magnétique https://fr.wikipedia.org/wiki/Champ_magn%C3%A9tique<br />
<br />
Pas facile à visualiser... on peut utiliser une analogie qui compare la charge avec la masse.<br />
* Dans un cours d'eau: goutte d'eau a une masse, à une altitude donnée.<br />
* Dans un courant électrique: chaque porteur de charge a une charge, à un potentiel donné.<br />
<br />
<br />
<br />
=== Quel intérêt ? quels usages ? ===<br />
Tout l'intérêt de l'électricité est dans ses interactions avec d'autres forces physiques, et en particulier l'énergie mécanique. L'électricité a l'avantage d'être un vecteur d'énergie très pratique : on peut stocker et transporter l'électricité beaucoup plus facilement que l'énergie mécanique.<br />
<br />
Comment on crée/stocke/transporte de l'électricité:<br />
* phénomènes chimiques, statiques, électromagnétiques => batterie, foudre, moteur<br />
* conducteurs électriques (fils, ...) et réseau secteur électrique<br />
<br />
Habituellement, ce qui nous intéresse dans l'électricité, c'est le déplacement de charges, plutôt qu'une accumulation de charges.<br />
=> courant/tension ; effets électromagnétiques (moteurs)<br />
<br />
On se sert de l'électricité pour faire tout un tas de conversions:<br />
* transformation d'énergie mécanique en énergie électrique dans une centrale, distribution dans un réseau électrique, puis utilisation pour faire tourner un moteur électrique (conversion dans l'autre sens)<br />
* apport d'énergie électrique pour modifier l'état chimique d'une pile lors de son rechargement, puis modification de l'état chimique d'une pile lorsqu'on en tire de l'énergie électrique pendant sa décharge. A noter que lorsqu'on charge la pile, on utilise au départ de l'énergie mécanique (à travers le réseau de distribution secteur), et souvent, on utilise à nouveau de l'énergie mécanique à la fin (moteur électrique).<br />
<br />
<br />
Il est primordial de bien comprendre la différence entre la puissance électrique (exprimée en Watts) et l'énergie (exprimée en Watts heure, même si ce n'est pas l'unité 'rigoureuse'). Exemple: un moteur de compresseur de frigo consomme lorsqu'il fonctionne 150W. S'il est en marche pendant une heure, il aura consommé 150Wh d'énergie. A noter qu'on convertit donc 150Wh d'énergie électrique (issue du réseau électrique) en énergie mécanique (compression du gaz dans le frigo pour le mécanisme de refroidissement).<br />
<br />
<br />
On fait parfois la distinction entre électricité et électronique: l'électronique est l'exploitation de l'électricité pour effectuer un transfert d'informations. L'électricité est le phénomène général, et parfois compris par opposition à l'électronique : lorsque l'électricité n'est utile que par le transfert d'énergie et pas d'information.<br />
<br />
<br />
En effet, l'électricité, au delà du transport d'énergie/de puissance, peut servir au transport d'informations. Deux grands modes de fonctionnement sont utilisés: information numérique (présence ou absence d'électricité) ou analogique (niveau de tension ou de courant). On parle dans un cas d'électronique numérique (ou digitale, par anglicisme), et d'électronique analogique de l'autre. Il existe encore d'autres subdivisions de l'électronique : électronique de puissance et électrotechnique (forte puissance, conversions d'énergie), électronique HF (hautes fréquences) ou RF (radio fréquences), microélectronique (miniaturisation de composants électronique), ... chacun de ces domaines emploie les même phénomènes physiques et repose sur les même règles fondamentales, que nous allons voir dans les chapitres suivants.<br />
<br />
Voir électronique niveau 2: analogique, électronique niveau 2: numérique, et autres formations.<br />
<br />
<br />
<br />
== Chapitre 2 : notions fondamentales ==<br />
* Notions fondamentales:<br />
** détails sur courant/tension<br />
** circuit électrique, composant et schéma<br />
** caractéristique d'un composant et loi d'Ohm<br />
<br />
<br />
* Outil: le multimètre (pour mesurer la tension et le courant)<br />
* Outil: l'alimentation stabilisée.<br />
* Pratique: mesure de caractéristique d'une R.<br />
* Pratique: circuit d'allumage du phare avant et veilleuses. Circuit de feu arrière de freinage.<br />
<br />
=== courant/tension ===<br />
*déplacement de charges (additivité, conservation). Phénomènes physiques intéressants liés au déplacement de charge: electromag, information.<br />
*analogie avec l'eau: débit et pression.<br />
*courant/tension: unités, ordres de grandeur<br />
*continu/alternatif.<br />
<br />
Pratique: le multimètre<br />
<br />
=== circuit électrique et schéma ===<br />
*Mouvements d'électrons: notion de circuit (rappel: cause ddp générée par electromag ou chimique, ou statique).<br />
*Notion de modèle/schématique. <br />
*qu'est ce qui "impose" le déplacement des charges et donc tension/courant? comprendre et prévoir.<br />
<br />
Pratique: alimentation stabilisée<br />
<br />
=== caractéristique d'un composant et loi d'Ohm ===<br />
Notion de composant/dipole/quadripole ; modélisation pour réfléchir/choisir le comportement, anticiper ce qu'il va se passer. Relations entre tensions et courant pour différents bidules. <br />
<br />
Exemple: une résistance.<br />
<br />
Pratique: caractéristique d'une résistance<br />
<br />
== Chapitre 3 : circuits usuels ==<br />
La plupart des schéma/circuits ne sont pas des boucles simples, mettent en oeuvre différents composants, aux caractéristiques parfois complexes.<br />
<br />
* Schémas usuels:<br />
** montage parallèle et série<br />
** lois de Kirshoff (loi des mailles, loi des nœuds)<br />
** pont diviseur de tension<br />
** aspects puissance, thermique, énergie et ordres de grandeurs<br />
** diodes et caractéristiques non linéaires<br />
<br />
=== Parallèle et série ===<br />
Résistances... avec manip.<br />
<br />
=== Lois de Kirshoff ===<br />
Lois de Kirshoff (loi des mailles, loi des noeuds). Thévenin/Norton: bof. Superposition: out.<br />
<br />
Exemples d'associations de résistances, calculs sur des circuits simples. Avec manip également ! => aspect prédictif de ces lois, et modèle satisfaisant pour réfléchir à ce qui se passe vs ce qu'on veut.<br />
<br />
=== Puissance, thermique, etc ===<br />
Pour aller plus loins/limites: d'autres cas pourris/ou les modeles simplistes ne marchent pas/ne suffisent pas: considérations de puissance et thermique, de résistance interne batterie, etc...<br />
<br />
=== diodes et caractéristique non linéaire ===<br />
Autre exemples: diodes et caractéristiques non linéaires ; autres composants avec des comportements phunkys (et donc intéressants) : bobines, condensateurs, transistors... y compris quand on en met plusieurs (circuit intégré genre NE555), voire PLEIN : électronique numérique. Autres sujets, renvois vers formations correspondantes.<br />
<br />
Manip: carac LED (courbe points de fonctionnement U/I)<br />
<br />
Cas pratique: application au vélo!<br />
<br />
Velo: batterie, switchs, résistances, leds<br />
* ajouter des leds et faire les veilleuses/eclairages genre phares<br />
* ajouter un circuit pour allumer feu arrière lors du freinage<br />
* clignotants: on est un peu embêtés... faut le faire à la mano (ou aller à la formation lvl2)<br />
<br />
velo: logique de clignotants (à la main.... mode volta :P) avec branche avant/arriere ; logique veilleuse/feu (eg phare avant, ou frein/veilleuse sur arriere) => switchs, parallèle, série, intensités (eg plus fort quand freine ou appel de phare... sur le meme truc!).<br />
<br />
<br />
== Conclusion ==<br />
Cette formation a permis: <br />
* de mieux comprendre ce qu'est l'électricité<br />
* d'aborder les notions fondamentales<br />
* d'examiner les circuits simples<br />
... et de faire un système d'éclairage vélo basique mais fonctionnel.<br />
<br />
La suite (par exemple) : <br />
* Animer vous même cette formation!<br />
* Autres formations: électronique numérique, analogique (lvl2: NE555, ampli op), puissance (transistors? moteurs?)<br />
* Ajouter des fonctions à l'éclairage du vélo<br />
<br />
=> Critiquez la formation, appropriez vous le contenu. <br />
<br />
A vous la parole (links pour feedback)</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:InitiationFormations:Arduino:Initiation2016-09-06T12:44:34Z<p>Clément: /* A propos de la programmation */</p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Formation Arduino: initiation =<br />
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!<br />
<br />
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers Arduino. <br />
<br />
== TODO/meta ==<br />
* 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?<br />
* ajouter shitloads of pictures<br />
* ajouter le module spoileralert pour masquer les réponses...<br />
* schéma frizting<br />
* prettyprint sourcecode...<br />
* couper en n pages (pour les 3 troncs de contenu, les annexes?), voire préparer pour migration vers learn.electrolab.fr<br />
<br />
== Informations pratiques ==<br />
* Durée: 3h voire plus<br />
* Public visé: tous les membres, niveau débutant en programmation/électronique/Arduino<br />
<br />
== Formations liées ==<br />
*Prérequis: aucun, à part savoir lire.<br />
* Idéalement:<br />
** notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
** notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
<br />
* Formations suivantes:<br />
** Mon premier projet Arduino<br />
<br />
== Matériel requis ==<br />
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<br />
<br />
<br />
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.<br />
<br />
Contenu :<br />
* Arduino Nano + cable USB<br />
* breadboard pour prototypage et cables male/male et femelle/femelle<br />
* potentiomètre et bouton poussoir (joystick)<br />
* leds rouge, verte, jaune, blanche, bleue, RGB et résistances 330 ohm<br />
* photorésistance & thermistance + set de résistances adaptées (2x1k, 2x10k, 2x100k)<br />
* micro-servomoteur, buzzer<br />
<br />
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.<br />
<br />
=== Installation IDE ===<br />
A déplacer au bon endroit/page de référence en la matiere:<br />
* voir https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide à traduire<br />
* 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.<br />
<br />
== Ressources additionnelles ==<br />
Pour se fournir en matériel:<br />
* 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<br />
* de nombreuses enseignes vendent du matériel lié à arduino: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== A propos d'Arduino ===<br />
* 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] <br />
* [https://www.arduino.cc/en/Guide/HomePage la page équivalente à celle-ci] directement sur le site official (en moins bien, forcément ;)<br />
* [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<br />
* reference francophone: pas mal de choses bien ici: http://eskimon.fr/<br />
* explorez les sites des vendeurs de matériel type Sparkfun, Adafruit Industries, ...<br />
* ouvrages papier: à mon humble avis, "Arduino pour les nuls" est pas mal.<br />
<br />
=== A propos de la programmation ===<br />
* notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
* voir [https://www.arduino.cc/en/Reference/HomePage les elements du langage de programmation et les librairies Arduino]<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique<br />
* https://fr.wikiversity.org/wiki/Introduction_g%C3%A9n%C3%A9rale_%C3%A0_la_programmation<br />
* https://fr.wikiversity.org/wiki/Introduction_au_langage_C<br />
<br />
=== A propos de l'electronique ===<br />
* notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|sur le wiki du lab]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique<br />
<br />
= Contenu détaillé =<br />
Cette formation est prevue pour être animée au lab.<br />
Il est envisageable de suivre le plan en autoformation (mais pour l'instant, cette page nécessite d'être étoffée).<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement.<br />
<br />
== Introduction ==<br />
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.<br />
<br />
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 !<br />
<br />
==== Préliminaires: notions d'électronique et d'informatique ====<br />
Pendant cette formation, nous allons manipuler:<br />
* des notions d'électronique :<br />
** électricité, tension/courant<br />
** circuit électrique, schémas et modèle<br />
* des notions d'informatique :<br />
** qu'est-ce que c'est qu'un programme? langage de programmation.<br />
** sémantique du langage et [https://www.arduino.cc/en/Reference/HomePage mots clés spécifiques Arduino].<br />
** étapes de travail: conception, écriture, compilation, tests & correctifs.<br />
<br />
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.<br />
<br />
<br />
=== Microcontrôleurs ===<br />
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<br />
<br />
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<br />
<br />
https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR<br />
<br />
<br />
==== Qu'est-ce qu'un microcontrôleur? ====<br />
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.<br />
<br />
TODO: picture d'un chip au centre d'une carte.<br />
<br />
==== Qu'est-ce qu'un microprocesseur ? ====<br />
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 :<br />
* ajouter la valeur 42 à la case mémoire #3<br />
* si la case mémoire #3 est nulle, aller exécuter l'instruction 2 cases plus bas dans la mémoire programme<br />
* sinon, exécuter celle 1 case plus bas dans la mémoire programme<br />
<br />
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.<br />
<br />
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"...<br />
<br />
==== Qu'est-ce que le binaire et le nombre de bits ? ====<br />
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.<br />
<br />
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.<br />
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 !<br />
<br />
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.<br />
<br />
<br />
Voir:<br />
* https://fr.wikiversity.org/wiki/Code_de_num%C3%A9ration/Introduction<br />
* https://fr.wikipedia.org/wiki/Virgule_fixe<br />
* https://fr.wikipedia.org/wiki/IEEE_754 (norme pour nombres à virgule: attention compliqué!)<br />
<br />
==== A quoi ca sert/où ca sert? ====<br />
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.<br />
<br />
TODO: picture synoptique système d'un objet courant simple, avec visu entrées, sorties, algorithme<br />
<br />
Par exemple: {système quelconque avec asservissement ou FSM, genre controleur de machine à laver? ou d'ascenceur?}<br />
<br />
<br />
==== Comment on s'en sert? ====<br />
* 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?<br />
* 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.<br />
* É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!<br />
* Tests, correctifs & modifications: rien ne marche jamais du premier coup...<br />
<br />
=== L'univers Arduino ===<br />
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!<br />
<br />
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.<br />
<br />
==== C'est quoi Arduino ? ====<br />
Par rapport à plein de cartes qui existaient auparavant, les gens d'Arduino ont fait plusieurs trucs géniaux:<br />
* 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.<br />
* 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.<br />
* 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.<br />
<br />
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.<br />
<br />
==== Anatomie d'une carte Arduino ====<br />
présentation de la Nano: photo, feature sheet.<br />
<br />
Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg image d'une Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png le pinout Arduino Nano]<br />
<br />
==== Fonctionnalités de notre carte Arduino ====<br />
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 :<br />
* 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.<br />
* 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..<br />
* 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).<br />
* 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 !<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Utiliser l'outil logiciel ====<br />
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.<br />
* menus (choix de carte/port, exemples)<br />
* boutons upload & terminal <br />
* fenêtre d'édition du programme<br />
TODO: pictures de partout.<br />
<br />
==== Installation des logiciels ====<br />
'''Installation/verification de l'IDE + du driver.'''<br />
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.<br />
<br />
TODO: pictures de partout.<br />
<br />
* Installation pas à pas de l'IDE<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== Le matériel ===<br />
Nous allons découvrir chacun des éléments du kit de découverte Arduino.<br />
<br />
TODO: pictures de partout ; est-ce qu'on renverrait pas vers des pages ailleurs qui contiennent ces infos?<br />
<br />
*Breadboard <br />
** Décrire comment marche une breadboard<br />
** Mises en garde/comment on fait un circuit<br />
* composant x:<br />
<br />
== Piloter des sorties ==<br />
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.<br />
<br />
=== Allumer et éteindre des LED ===<br />
<br />
==== Exemple "blink" et fonctions de base ====<br />
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.<br />
<br />
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.<br />
<br />
Cette manipulation simple représente le B.A.BA de l'utilisation de microcontrôleurs: bravo, vous venez de faire votre premier pas :)<br />
<br />
<br />
'''Le montage:'''<br />
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 ! <br />
<br />
TODO: pictures.<br />
<br />
'''Comprendre le schéma:'''<br />
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.<br />
<br />
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 !<br />
<br />
TODO: picture schematic sortie arduino resistance led.<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient quatre instructions:<br />
** on allume la led, en mettant la sortie 13 à l'état haut<br />
** on attend 1000 millisecondes, soit une seconde<br />
** on éteint la led, en mettant la sortie 13 à l'état bas<br />
** on attend 1000 millisecondes, soit une seconde<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Défi 1: changer la vitesse de clignottement ====<br />
Question: Comment on fait pour changer la vitesse à laquelle clignote la led ?<br />
<br />
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.<br />
<br />
Réponse: {masqué!}<br />
* en changeant la valeur 1000, on modifie le temps d'attente après avoir allumé ou éteint la led. Par exemple:<br />
** en mettant 200 et 200, la led clignote 5 fois plus vite<br />
** en mettant 2000 et 2000, la led clignote 2 fois plus lentement<br />
** en mettant 500 et 1500, la led clignote à la même vitesse, mais est allumée moins longtemps<br />
<br />
Résultat:<br />
* Compréhension d'un premier programme<br />
* Passage immédiat à l'action et interaction immédiate avec le sujet d'étude<br />
<br />
==== Défi 2: SOS morse ====<br />
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.<br />
<br />
Question pratique: faites donc un afficheur de SOS en morse sur la led L !<br />
<br />
Réponses: <br />
* diversité d'approches, de stratégies:<br />
** on peut faire de simples copier coller des 4 lignes de l'exemple de départ<br />
** utiliser des fonctions: créer une fonction flash_court() et une fonction flash-long(), par exemple<br />
* 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;<br />
<br />
Résultat:<br />
* on a désormais un programme un peu plus sophistiqué que le simple clignotement<br />
<br />
<br />
Questions subsidiaires:<br />
* 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"<br />
* 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).<br />
<br />
<br />
TODO: pretty print source code de ces questions subsidiaires<br />
<br />
En conclusion: même sur un exemple simple, bien structurer son programme et anticiper ce à quoi il va pouvoir servir est important.<br />
<br />
=== Allumer des LED avec intensité variable ===<br />
<br />
==== Défi 3: ultra rapide ====<br />
Question: Il se passe quoi si on fait clignoter suuuper vite?<br />
<br />
Là encore: faites le test! Mettez ''delay(100)'', puis ''delay(10)'' et ''delay(1)''.<br />
<br />
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.<br />
<br />
Question: ajuster la vitesse de clignotement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.<br />
<br />
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 !<br />
<br />
Question: ca veut dire quoi, super vite, pour le microcontrôleur?<br />
<br />
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... <br />
<br />
==== Défi 4 : jouer avec les délais ====<br />
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:InitiationFormations:Arduino:Initiation2016-09-06T12:28:21Z<p>Clément: /* Qu'est-ce que le binaire et le nombre de bits ? */</p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Formation Arduino: initiation =<br />
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!<br />
<br />
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers Arduino. <br />
<br />
== TODO/meta ==<br />
* 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?<br />
* ajouter shitloads of pictures<br />
* ajouter le module spoileralert pour masquer les réponses...<br />
* schéma frizting<br />
* prettyprint sourcecode...<br />
* couper en n pages (pour les 3 troncs de contenu, les annexes?), voire préparer pour migration vers learn.electrolab.fr<br />
<br />
== Informations pratiques ==<br />
* Durée: 3h voire plus<br />
* Public visé: tous les membres, niveau débutant en programmation/électronique/Arduino<br />
<br />
== Formations liées ==<br />
*Prérequis: aucun, à part savoir lire.<br />
* Idéalement:<br />
** notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
** notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
<br />
* Formations suivantes:<br />
** Mon premier projet Arduino<br />
<br />
== Matériel requis ==<br />
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<br />
<br />
<br />
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.<br />
<br />
Contenu :<br />
* Arduino Nano + cable USB<br />
* breadboard pour prototypage et cables male/male et femelle/femelle<br />
* potentiomètre et bouton poussoir (joystick)<br />
* leds rouge, verte, jaune, blanche, bleue, RGB et résistances 330 ohm<br />
* photorésistance & thermistance + set de résistances adaptées (2x1k, 2x10k, 2x100k)<br />
* micro-servomoteur, buzzer<br />
<br />
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.<br />
<br />
=== Installation IDE ===<br />
A déplacer au bon endroit/page de référence en la matiere:<br />
* voir https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide à traduire<br />
* 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.<br />
<br />
== Ressources additionnelles ==<br />
Pour se fournir en matériel:<br />
* 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<br />
* de nombreuses enseignes vendent du matériel lié à arduino: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== A propos d'Arduino ===<br />
* 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] <br />
* [https://www.arduino.cc/en/Guide/HomePage la page équivalente à celle-ci] directement sur le site official (en moins bien, forcément ;)<br />
* [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<br />
* reference francophone: pas mal de choses bien ici: http://eskimon.fr/<br />
* explorez les sites des vendeurs de matériel type Sparkfun, Adafruit Industries, ...<br />
* ouvrages papier: à mon humble avis, "Arduino pour les nuls" est pas mal.<br />
<br />
=== A propos de la programmation ===<br />
* notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
* voir [https://www.arduino.cc/en/Reference/HomePage les elements du langage de programmation et les librairies Arduino]<br />
* https://en.wikiversity.org/wiki/Introduction_to_Programming/About_Programming<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique<br />
<br />
=== A propos de l'electronique ===<br />
* notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|sur le wiki du lab]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique<br />
<br />
= Contenu détaillé =<br />
Cette formation est prevue pour être animée au lab.<br />
Il est envisageable de suivre le plan en autoformation (mais pour l'instant, cette page nécessite d'être étoffée).<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement.<br />
<br />
== Introduction ==<br />
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.<br />
<br />
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 !<br />
<br />
==== Préliminaires: notions d'électronique et d'informatique ====<br />
Pendant cette formation, nous allons manipuler:<br />
* des notions d'électronique :<br />
** électricité, tension/courant<br />
** circuit électrique, schémas et modèle<br />
* des notions d'informatique :<br />
** qu'est-ce que c'est qu'un programme? langage de programmation.<br />
** sémantique du langage et [https://www.arduino.cc/en/Reference/HomePage mots clés spécifiques Arduino].<br />
** étapes de travail: conception, écriture, compilation, tests & correctifs.<br />
<br />
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.<br />
<br />
<br />
=== Microcontrôleurs ===<br />
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<br />
<br />
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<br />
<br />
https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR<br />
<br />
<br />
==== Qu'est-ce qu'un microcontrôleur? ====<br />
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.<br />
<br />
TODO: picture d'un chip au centre d'une carte.<br />
<br />
==== Qu'est-ce qu'un microprocesseur ? ====<br />
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 :<br />
* ajouter la valeur 42 à la case mémoire #3<br />
* si la case mémoire #3 est nulle, aller exécuter l'instruction 2 cases plus bas dans la mémoire programme<br />
* sinon, exécuter celle 1 case plus bas dans la mémoire programme<br />
<br />
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.<br />
<br />
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"...<br />
<br />
==== Qu'est-ce que le binaire et le nombre de bits ? ====<br />
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.<br />
<br />
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.<br />
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 !<br />
<br />
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.<br />
<br />
<br />
Voir:<br />
* https://fr.wikiversity.org/wiki/Code_de_num%C3%A9ration/Introduction<br />
* https://fr.wikipedia.org/wiki/Virgule_fixe<br />
* https://fr.wikipedia.org/wiki/IEEE_754 (norme pour nombres à virgule: attention compliqué!)<br />
<br />
==== A quoi ca sert/où ca sert? ====<br />
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.<br />
<br />
TODO: picture synoptique système d'un objet courant simple, avec visu entrées, sorties, algorithme<br />
<br />
Par exemple: {système quelconque avec asservissement ou FSM, genre controleur de machine à laver? ou d'ascenceur?}<br />
<br />
<br />
==== Comment on s'en sert? ====<br />
* 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?<br />
* 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.<br />
* É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!<br />
* Tests, correctifs & modifications: rien ne marche jamais du premier coup...<br />
<br />
=== L'univers Arduino ===<br />
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!<br />
<br />
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.<br />
<br />
==== C'est quoi Arduino ? ====<br />
Par rapport à plein de cartes qui existaient auparavant, les gens d'Arduino ont fait plusieurs trucs géniaux:<br />
* 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.<br />
* 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.<br />
* 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.<br />
<br />
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.<br />
<br />
==== Anatomie d'une carte Arduino ====<br />
présentation de la Nano: photo, feature sheet.<br />
<br />
Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg image d'une Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png le pinout Arduino Nano]<br />
<br />
==== Fonctionnalités de notre carte Arduino ====<br />
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 :<br />
* 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.<br />
* 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..<br />
* 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).<br />
* 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 !<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Utiliser l'outil logiciel ====<br />
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.<br />
* menus (choix de carte/port, exemples)<br />
* boutons upload & terminal <br />
* fenêtre d'édition du programme<br />
TODO: pictures de partout.<br />
<br />
==== Installation des logiciels ====<br />
'''Installation/verification de l'IDE + du driver.'''<br />
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.<br />
<br />
TODO: pictures de partout.<br />
<br />
* Installation pas à pas de l'IDE<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== Le matériel ===<br />
Nous allons découvrir chacun des éléments du kit de découverte Arduino.<br />
<br />
TODO: pictures de partout ; est-ce qu'on renverrait pas vers des pages ailleurs qui contiennent ces infos?<br />
<br />
*Breadboard <br />
** Décrire comment marche une breadboard<br />
** Mises en garde/comment on fait un circuit<br />
* composant x:<br />
<br />
== Piloter des sorties ==<br />
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.<br />
<br />
=== Allumer et éteindre des LED ===<br />
<br />
==== Exemple "blink" et fonctions de base ====<br />
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.<br />
<br />
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.<br />
<br />
Cette manipulation simple représente le B.A.BA de l'utilisation de microcontrôleurs: bravo, vous venez de faire votre premier pas :)<br />
<br />
<br />
'''Le montage:'''<br />
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 ! <br />
<br />
TODO: pictures.<br />
<br />
'''Comprendre le schéma:'''<br />
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.<br />
<br />
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 !<br />
<br />
TODO: picture schematic sortie arduino resistance led.<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient quatre instructions:<br />
** on allume la led, en mettant la sortie 13 à l'état haut<br />
** on attend 1000 millisecondes, soit une seconde<br />
** on éteint la led, en mettant la sortie 13 à l'état bas<br />
** on attend 1000 millisecondes, soit une seconde<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Défi 1: changer la vitesse de clignottement ====<br />
Question: Comment on fait pour changer la vitesse à laquelle clignote la led ?<br />
<br />
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.<br />
<br />
Réponse: {masqué!}<br />
* en changeant la valeur 1000, on modifie le temps d'attente après avoir allumé ou éteint la led. Par exemple:<br />
** en mettant 200 et 200, la led clignote 5 fois plus vite<br />
** en mettant 2000 et 2000, la led clignote 2 fois plus lentement<br />
** en mettant 500 et 1500, la led clignote à la même vitesse, mais est allumée moins longtemps<br />
<br />
Résultat:<br />
* Compréhension d'un premier programme<br />
* Passage immédiat à l'action et interaction immédiate avec le sujet d'étude<br />
<br />
==== Défi 2: SOS morse ====<br />
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.<br />
<br />
Question pratique: faites donc un afficheur de SOS en morse sur la led L !<br />
<br />
Réponses: <br />
* diversité d'approches, de stratégies:<br />
** on peut faire de simples copier coller des 4 lignes de l'exemple de départ<br />
** utiliser des fonctions: créer une fonction flash_court() et une fonction flash-long(), par exemple<br />
* 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;<br />
<br />
Résultat:<br />
* on a désormais un programme un peu plus sophistiqué que le simple clignotement<br />
<br />
<br />
Questions subsidiaires:<br />
* 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"<br />
* 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).<br />
<br />
<br />
TODO: pretty print source code de ces questions subsidiaires<br />
<br />
En conclusion: même sur un exemple simple, bien structurer son programme et anticiper ce à quoi il va pouvoir servir est important.<br />
<br />
=== Allumer des LED avec intensité variable ===<br />
<br />
==== Défi 3: ultra rapide ====<br />
Question: Il se passe quoi si on fait clignoter suuuper vite?<br />
<br />
Là encore: faites le test! Mettez ''delay(100)'', puis ''delay(10)'' et ''delay(1)''.<br />
<br />
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.<br />
<br />
Question: ajuster la vitesse de clignotement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.<br />
<br />
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 !<br />
<br />
Question: ca veut dire quoi, super vite, pour le microcontrôleur?<br />
<br />
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... <br />
<br />
==== Défi 4 : jouer avec les délais ====<br />
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:InitiationFormations:Arduino:Initiation2016-09-06T12:22:22Z<p>Clément: /* Microcontrôleurs */</p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Formation Arduino: initiation =<br />
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!<br />
<br />
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers Arduino. <br />
<br />
== TODO/meta ==<br />
* 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?<br />
* ajouter shitloads of pictures<br />
* ajouter le module spoileralert pour masquer les réponses...<br />
* schéma frizting<br />
* prettyprint sourcecode...<br />
* couper en n pages (pour les 3 troncs de contenu, les annexes?), voire préparer pour migration vers learn.electrolab.fr<br />
<br />
== Informations pratiques ==<br />
* Durée: 3h voire plus<br />
* Public visé: tous les membres, niveau débutant en programmation/électronique/Arduino<br />
<br />
== Formations liées ==<br />
*Prérequis: aucun, à part savoir lire.<br />
* Idéalement:<br />
** notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
** notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
<br />
* Formations suivantes:<br />
** Mon premier projet Arduino<br />
<br />
== Matériel requis ==<br />
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<br />
<br />
<br />
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.<br />
<br />
Contenu :<br />
* Arduino Nano + cable USB<br />
* breadboard pour prototypage et cables male/male et femelle/femelle<br />
* potentiomètre et bouton poussoir (joystick)<br />
* leds rouge, verte, jaune, blanche, bleue, RGB et résistances 330 ohm<br />
* photorésistance & thermistance + set de résistances adaptées (2x1k, 2x10k, 2x100k)<br />
* micro-servomoteur, buzzer<br />
<br />
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.<br />
<br />
=== Installation IDE ===<br />
A déplacer au bon endroit/page de référence en la matiere:<br />
* voir https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide à traduire<br />
* 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.<br />
<br />
== Ressources additionnelles ==<br />
Pour se fournir en matériel:<br />
* 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<br />
* de nombreuses enseignes vendent du matériel lié à arduino: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== A propos d'Arduino ===<br />
* 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] <br />
* [https://www.arduino.cc/en/Guide/HomePage la page équivalente à celle-ci] directement sur le site official (en moins bien, forcément ;)<br />
* [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<br />
* reference francophone: pas mal de choses bien ici: http://eskimon.fr/<br />
* explorez les sites des vendeurs de matériel type Sparkfun, Adafruit Industries, ...<br />
* ouvrages papier: à mon humble avis, "Arduino pour les nuls" est pas mal.<br />
<br />
=== A propos de la programmation ===<br />
* notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
* voir [https://www.arduino.cc/en/Reference/HomePage les elements du langage de programmation et les librairies Arduino]<br />
* https://en.wikiversity.org/wiki/Introduction_to_Programming/About_Programming<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique<br />
<br />
=== A propos de l'electronique ===<br />
* notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|sur le wiki du lab]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique<br />
<br />
= Contenu détaillé =<br />
Cette formation est prevue pour être animée au lab.<br />
Il est envisageable de suivre le plan en autoformation (mais pour l'instant, cette page nécessite d'être étoffée).<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement.<br />
<br />
== Introduction ==<br />
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.<br />
<br />
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 !<br />
<br />
==== Préliminaires: notions d'électronique et d'informatique ====<br />
Pendant cette formation, nous allons manipuler:<br />
* des notions d'électronique :<br />
** électricité, tension/courant<br />
** circuit électrique, schémas et modèle<br />
* des notions d'informatique :<br />
** qu'est-ce que c'est qu'un programme? langage de programmation.<br />
** sémantique du langage et [https://www.arduino.cc/en/Reference/HomePage mots clés spécifiques Arduino].<br />
** étapes de travail: conception, écriture, compilation, tests & correctifs.<br />
<br />
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.<br />
<br />
<br />
=== Microcontrôleurs ===<br />
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<br />
<br />
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<br />
<br />
https://fr.wikiversity.org/wiki/Micro_contr%C3%B4leurs_AVR<br />
<br />
<br />
==== Qu'est-ce qu'un microcontrôleur? ====<br />
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.<br />
<br />
TODO: picture d'un chip au centre d'une carte.<br />
<br />
==== Qu'est-ce qu'un microprocesseur ? ====<br />
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 :<br />
* ajouter la valeur 42 à la case mémoire #3<br />
* si la case mémoire #3 est nulle, aller exécuter l'instruction 2 cases plus bas dans la mémoire programme<br />
* sinon, exécuter celle 1 case plus bas dans la mémoire programme<br />
<br />
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.<br />
<br />
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"...<br />
<br />
==== Qu'est-ce que le binaire et le nombre de bits ? ====<br />
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.<br />
<br />
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.<br />
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 !<br />
<br />
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.<br />
<br />
==== A quoi ca sert/où ca sert? ====<br />
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.<br />
<br />
TODO: picture synoptique système d'un objet courant simple, avec visu entrées, sorties, algorithme<br />
<br />
Par exemple: {système quelconque avec asservissement ou FSM, genre controleur de machine à laver? ou d'ascenceur?}<br />
<br />
<br />
==== Comment on s'en sert? ====<br />
* 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?<br />
* 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.<br />
* É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!<br />
* Tests, correctifs & modifications: rien ne marche jamais du premier coup...<br />
<br />
=== L'univers Arduino ===<br />
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!<br />
<br />
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.<br />
<br />
==== C'est quoi Arduino ? ====<br />
Par rapport à plein de cartes qui existaient auparavant, les gens d'Arduino ont fait plusieurs trucs géniaux:<br />
* 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.<br />
* 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.<br />
* 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.<br />
<br />
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.<br />
<br />
==== Anatomie d'une carte Arduino ====<br />
présentation de la Nano: photo, feature sheet.<br />
<br />
Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg image d'une Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png le pinout Arduino Nano]<br />
<br />
==== Fonctionnalités de notre carte Arduino ====<br />
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 :<br />
* 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.<br />
* 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..<br />
* 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).<br />
* 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 !<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Utiliser l'outil logiciel ====<br />
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.<br />
* menus (choix de carte/port, exemples)<br />
* boutons upload & terminal <br />
* fenêtre d'édition du programme<br />
TODO: pictures de partout.<br />
<br />
==== Installation des logiciels ====<br />
'''Installation/verification de l'IDE + du driver.'''<br />
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.<br />
<br />
TODO: pictures de partout.<br />
<br />
* Installation pas à pas de l'IDE<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== Le matériel ===<br />
Nous allons découvrir chacun des éléments du kit de découverte Arduino.<br />
<br />
TODO: pictures de partout ; est-ce qu'on renverrait pas vers des pages ailleurs qui contiennent ces infos?<br />
<br />
*Breadboard <br />
** Décrire comment marche une breadboard<br />
** Mises en garde/comment on fait un circuit<br />
* composant x:<br />
<br />
== Piloter des sorties ==<br />
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.<br />
<br />
=== Allumer et éteindre des LED ===<br />
<br />
==== Exemple "blink" et fonctions de base ====<br />
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.<br />
<br />
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.<br />
<br />
Cette manipulation simple représente le B.A.BA de l'utilisation de microcontrôleurs: bravo, vous venez de faire votre premier pas :)<br />
<br />
<br />
'''Le montage:'''<br />
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 ! <br />
<br />
TODO: pictures.<br />
<br />
'''Comprendre le schéma:'''<br />
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.<br />
<br />
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 !<br />
<br />
TODO: picture schematic sortie arduino resistance led.<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient quatre instructions:<br />
** on allume la led, en mettant la sortie 13 à l'état haut<br />
** on attend 1000 millisecondes, soit une seconde<br />
** on éteint la led, en mettant la sortie 13 à l'état bas<br />
** on attend 1000 millisecondes, soit une seconde<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Défi 1: changer la vitesse de clignottement ====<br />
Question: Comment on fait pour changer la vitesse à laquelle clignote la led ?<br />
<br />
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.<br />
<br />
Réponse: {masqué!}<br />
* en changeant la valeur 1000, on modifie le temps d'attente après avoir allumé ou éteint la led. Par exemple:<br />
** en mettant 200 et 200, la led clignote 5 fois plus vite<br />
** en mettant 2000 et 2000, la led clignote 2 fois plus lentement<br />
** en mettant 500 et 1500, la led clignote à la même vitesse, mais est allumée moins longtemps<br />
<br />
Résultat:<br />
* Compréhension d'un premier programme<br />
* Passage immédiat à l'action et interaction immédiate avec le sujet d'étude<br />
<br />
==== Défi 2: SOS morse ====<br />
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.<br />
<br />
Question pratique: faites donc un afficheur de SOS en morse sur la led L !<br />
<br />
Réponses: <br />
* diversité d'approches, de stratégies:<br />
** on peut faire de simples copier coller des 4 lignes de l'exemple de départ<br />
** utiliser des fonctions: créer une fonction flash_court() et une fonction flash-long(), par exemple<br />
* 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;<br />
<br />
Résultat:<br />
* on a désormais un programme un peu plus sophistiqué que le simple clignotement<br />
<br />
<br />
Questions subsidiaires:<br />
* 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"<br />
* 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).<br />
<br />
<br />
TODO: pretty print source code de ces questions subsidiaires<br />
<br />
En conclusion: même sur un exemple simple, bien structurer son programme et anticiper ce à quoi il va pouvoir servir est important.<br />
<br />
=== Allumer des LED avec intensité variable ===<br />
<br />
==== Défi 3: ultra rapide ====<br />
Question: Il se passe quoi si on fait clignoter suuuper vite?<br />
<br />
Là encore: faites le test! Mettez ''delay(100)'', puis ''delay(10)'' et ''delay(1)''.<br />
<br />
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.<br />
<br />
Question: ajuster la vitesse de clignotement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.<br />
<br />
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 !<br />
<br />
Question: ca veut dire quoi, super vite, pour le microcontrôleur?<br />
<br />
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... <br />
<br />
==== Défi 4 : jouer avec les délais ====<br />
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clémenthttps://wiki.electrolab.fr/Formations:Arduino:InitiationFormations:Arduino:Initiation2016-09-06T12:21:03Z<p>Clément: /* Ressources additionnelles */</p>
<hr />
<div>[[Category:Formation | Initiation Arduino]]<br />
<br />
= Formation Arduino: initiation =<br />
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!<br />
<br />
Cette formation s'adresse à tous, et permet de faire ses premiers pas dans l'univers Arduino. <br />
<br />
== TODO/meta ==<br />
* 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?<br />
* ajouter shitloads of pictures<br />
* ajouter le module spoileralert pour masquer les réponses...<br />
* schéma frizting<br />
* prettyprint sourcecode...<br />
* couper en n pages (pour les 3 troncs de contenu, les annexes?), voire préparer pour migration vers learn.electrolab.fr<br />
<br />
== Informations pratiques ==<br />
* Durée: 3h voire plus<br />
* Public visé: tous les membres, niveau débutant en programmation/électronique/Arduino<br />
<br />
== Formations liées ==<br />
*Prérequis: aucun, à part savoir lire.<br />
* Idéalement:<br />
** notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
** notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
<br />
* Formations suivantes:<br />
** Mon premier projet Arduino<br />
<br />
== Matériel requis ==<br />
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<br />
<br />
<br />
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.<br />
<br />
Contenu :<br />
* Arduino Nano + cable USB<br />
* breadboard pour prototypage et cables male/male et femelle/femelle<br />
* potentiomètre et bouton poussoir (joystick)<br />
* leds rouge, verte, jaune, blanche, bleue, RGB et résistances 330 ohm<br />
* photorésistance & thermistance + set de résistances adaptées (2x1k, 2x10k, 2x100k)<br />
* micro-servomoteur, buzzer<br />
<br />
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.<br />
<br />
=== Installation IDE ===<br />
A déplacer au bon endroit/page de référence en la matiere:<br />
* voir https://www.arduino.cc/en/Main/Software#<br />
* https://learn.sparkfun.com/tutorials/installing-arduino-ide à traduire<br />
* 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.<br />
<br />
== Ressources additionnelles ==<br />
Pour se fournir en matériel:<br />
* 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<br />
* de nombreuses enseignes vendent du matériel lié à arduino: Sparkfun, Adafruit Industries, Lextronic, Snootlab, etc<br />
<br />
=== A propos d'Arduino ===<br />
* 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] <br />
* [https://www.arduino.cc/en/Guide/HomePage la page équivalente à celle-ci] directement sur le site official (en moins bien, forcément ;)<br />
* [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<br />
* reference francophone: pas mal de choses bien ici: http://eskimon.fr/<br />
* explorez les sites des vendeurs de matériel type Sparkfun, Adafruit Industries, ...<br />
* ouvrages papier: à mon humble avis, "Arduino pour les nuls" est pas mal.<br />
<br />
=== A propos de la programmation ===<br />
* notions basiques de programmation : voir la [[Formations:Programmation:Initiation|formation à ce sujet]]<br />
* voir [https://www.arduino.cc/en/Reference/HomePage les elements du langage de programmation et les librairies Arduino]<br />
* https://en.wikiversity.org/wiki/Introduction_to_Programming/About_Programming<br />
* https://fr.wikiversity.org/wiki/Facult%C3%A9:Informatique<br />
<br />
=== A propos de l'electronique ===<br />
* notions basiques d'électronique : voir la [[Formations:Electronique:Initiation|formation à ce sujet]]<br />
* how to electronique: [[Ressources#Notions_de_base_en_.C3.A9lectricit.C3.A9.2C_.C3.A9lectronique_et_sch.C3.A9ma|sur le wiki du lab]]<br />
* https://fr.wikiversity.org/wiki/D%C3%A9partement:%C3%89lectronique_et_Automatique<br />
<br />
= Contenu détaillé =<br />
Cette formation est prevue pour être animée au lab.<br />
Il est envisageable de suivre le plan en autoformation (mais pour l'instant, cette page nécessite d'être étoffée).<br />
Le slide-pack est en cours de creation et sera mis à disposition ici prochainement.<br />
<br />
== Introduction ==<br />
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.<br />
<br />
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 !<br />
<br />
==== Préliminaires: notions d'électronique et d'informatique ====<br />
Pendant cette formation, nous allons manipuler:<br />
* des notions d'électronique :<br />
** électricité, tension/courant<br />
** circuit électrique, schémas et modèle<br />
* des notions d'informatique :<br />
** qu'est-ce que c'est qu'un programme? langage de programmation.<br />
** sémantique du langage et [https://www.arduino.cc/en/Reference/HomePage mots clés spécifiques Arduino].<br />
** étapes de travail: conception, écriture, compilation, tests & correctifs.<br />
<br />
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.<br />
<br />
<br />
=== Microcontrôleurs ===<br />
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<br />
<br />
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<br />
<br />
==== Qu'est-ce qu'un microcontrôleur? ====<br />
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.<br />
<br />
TODO: picture d'un chip au centre d'une carte.<br />
<br />
==== Qu'est-ce qu'un microprocesseur ? ====<br />
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 :<br />
* ajouter la valeur 42 à la case mémoire #3<br />
* si la case mémoire #3 est nulle, aller exécuter l'instruction 2 cases plus bas dans la mémoire programme<br />
* sinon, exécuter celle 1 case plus bas dans la mémoire programme<br />
<br />
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.<br />
<br />
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"...<br />
<br />
==== Qu'est-ce que le binaire et le nombre de bits ? ====<br />
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.<br />
<br />
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.<br />
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 !<br />
<br />
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.<br />
<br />
==== A quoi ca sert/où ca sert? ====<br />
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.<br />
<br />
TODO: picture synoptique système d'un objet courant simple, avec visu entrées, sorties, algorithme<br />
<br />
Par exemple: {système quelconque avec asservissement ou FSM, genre controleur de machine à laver? ou d'ascenceur?}<br />
<br />
<br />
==== Comment on s'en sert? ====<br />
* 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?<br />
* 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.<br />
* É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!<br />
* Tests, correctifs & modifications: rien ne marche jamais du premier coup...<br />
<br />
=== L'univers Arduino ===<br />
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!<br />
<br />
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.<br />
<br />
==== C'est quoi Arduino ? ====<br />
Par rapport à plein de cartes qui existaient auparavant, les gens d'Arduino ont fait plusieurs trucs géniaux:<br />
* 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.<br />
* 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.<br />
* 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.<br />
<br />
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.<br />
<br />
==== Anatomie d'une carte Arduino ====<br />
présentation de la Nano: photo, feature sheet.<br />
<br />
Dans le cadre de cette formation, nous allons utiliser une carte qui contient tout le nécessaire: une Arduino Nano.<br />
<br />
[https://www.arduino.cc/en/uploads/Guide/ArduinoNanoUSBCable.jpg image d'une Nano]<br />
<br />
<br />
[http://letmeknow.fr/image_vente/Arduino%20Nano/Pinout.png le pinout Arduino Nano]<br />
<br />
==== Fonctionnalités de notre carte Arduino ====<br />
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 :<br />
* 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.<br />
* 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..<br />
* 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).<br />
* 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 !<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Utiliser l'outil logiciel ====<br />
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.<br />
* menus (choix de carte/port, exemples)<br />
* boutons upload & terminal <br />
* fenêtre d'édition du programme<br />
TODO: pictures de partout.<br />
<br />
==== Installation des logiciels ====<br />
'''Installation/verification de l'IDE + du driver.'''<br />
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.<br />
<br />
TODO: pictures de partout.<br />
<br />
* Installation pas à pas de l'IDE<br />
* Installation pas à pas du driver<br />
<br />
<br />
<br />
<br />
=== Le matériel ===<br />
Nous allons découvrir chacun des éléments du kit de découverte Arduino.<br />
<br />
TODO: pictures de partout ; est-ce qu'on renverrait pas vers des pages ailleurs qui contiennent ces infos?<br />
<br />
*Breadboard <br />
** Décrire comment marche une breadboard<br />
** Mises en garde/comment on fait un circuit<br />
* composant x:<br />
<br />
== Piloter des sorties ==<br />
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.<br />
<br />
=== Allumer et éteindre des LED ===<br />
<br />
==== Exemple "blink" et fonctions de base ====<br />
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.<br />
<br />
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.<br />
<br />
Cette manipulation simple représente le B.A.BA de l'utilisation de microcontrôleurs: bravo, vous venez de faire votre premier pas :)<br />
<br />
<br />
'''Le montage:'''<br />
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 ! <br />
<br />
TODO: pictures.<br />
<br />
'''Comprendre le schéma:'''<br />
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.<br />
<br />
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 !<br />
<br />
TODO: picture schematic sortie arduino resistance led.<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient quatre instructions:<br />
** on allume la led, en mettant la sortie 13 à l'état haut<br />
** on attend 1000 millisecondes, soit une seconde<br />
** on éteint la led, en mettant la sortie 13 à l'état bas<br />
** on attend 1000 millisecondes, soit une seconde<br />
<br />
TODO: pretty print source code blink<br />
<br />
==== Défi 1: changer la vitesse de clignottement ====<br />
Question: Comment on fait pour changer la vitesse à laquelle clignote la led ?<br />
<br />
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.<br />
<br />
Réponse: {masqué!}<br />
* en changeant la valeur 1000, on modifie le temps d'attente après avoir allumé ou éteint la led. Par exemple:<br />
** en mettant 200 et 200, la led clignote 5 fois plus vite<br />
** en mettant 2000 et 2000, la led clignote 2 fois plus lentement<br />
** en mettant 500 et 1500, la led clignote à la même vitesse, mais est allumée moins longtemps<br />
<br />
Résultat:<br />
* Compréhension d'un premier programme<br />
* Passage immédiat à l'action et interaction immédiate avec le sujet d'étude<br />
<br />
==== Défi 2: SOS morse ====<br />
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.<br />
<br />
Question pratique: faites donc un afficheur de SOS en morse sur la led L !<br />
<br />
Réponses: <br />
* diversité d'approches, de stratégies:<br />
** on peut faire de simples copier coller des 4 lignes de l'exemple de départ<br />
** utiliser des fonctions: créer une fonction flash_court() et une fonction flash-long(), par exemple<br />
* 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;<br />
<br />
Résultat:<br />
* on a désormais un programme un peu plus sophistiqué que le simple clignotement<br />
<br />
<br />
Questions subsidiaires:<br />
* 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"<br />
* 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).<br />
<br />
<br />
TODO: pretty print source code de ces questions subsidiaires<br />
<br />
En conclusion: même sur un exemple simple, bien structurer son programme et anticiper ce à quoi il va pouvoir servir est important.<br />
<br />
=== Allumer des LED avec intensité variable ===<br />
<br />
==== Défi 3: ultra rapide ====<br />
Question: Il se passe quoi si on fait clignoter suuuper vite?<br />
<br />
Là encore: faites le test! Mettez ''delay(100)'', puis ''delay(10)'' et ''delay(1)''.<br />
<br />
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.<br />
<br />
Question: ajuster la vitesse de clignotement pour identifier à partir de quand on ne distingue plus vraiment chaque flash.<br />
<br />
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 !<br />
<br />
Question: ca veut dire quoi, super vite, pour le microcontrôleur?<br />
<br />
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... <br />
<br />
==== Défi 4 : jouer avec les délais ====<br />
Question: il se passe quoi quand on a des valeurs de ''delay'' différentes ?<br />
<br />
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...<br />
<br />
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.<br />
<br />
==== Notion de PWM et sortie analogique ====<br />
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.<br />
<br />
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.<br />
<br />
TODO: pictures pour l'explication PWM/rapport cyclique, etc<br />
<br />
TODO: pictures Schéma U/T pour visualiser la forme d'onde générée, et la moyenne.<br />
<br />
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...<br />
<br />
==== Défi 5 : générer une sortie analogique à partir de 0v et 5v ====<br />
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]).<br />
<br />
<br />
Histoire de mieux comprendre ce qu'il se passe, on peut tenter d'en écrire nous même une version.<br />
On va créer une fonction my_analogWrite(int pin, int value):<br />
* pin étant une valeur de pin (qui devra avoir été configurée en sortie dans le setup() bien évidemment).<br />
* value étant une valeur entre 0 et 255, donnant l'intensité<br />
Solution primitive: on pourrait utiliser quelque chose du genre de:<br />
*digitalWrite(pin, HIGH); delay(value);digitalWrite(pin, LOW); delay(255-value);<br />
<br />
Probleme: 255 millisecondes, ca fait un peu beaucoup, comme période: seulement 4 clignotements par seconde... comment faire pour en avoir au moins 50?<br />
<br />
Réponse: on peut utiliser la fonction [https://www.arduino.cc/en/Reference/DelayMicroseconds DelayMicroseconds] au lieu de delay tout court:<br />
*digitalWrite(pin, HIGH); delayMicroseconds(100*value);digitalWrite(pin, LOW); delayMicroseconds(100*(255-value));<br />
<br />
TODO: Code en pretty print<br />
<br />
<br />
<br />
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].<br />
<br />
Ouille ouille ouille, on voit bien que le code est un peu plus compliqué que le notre ! Plusieurs raisons à cela:<br />
* il est générique, et marche sur plusieurs types de cartes Arduino (il <br />
* 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...<br />
<br />
==== Exemple Fade et fonction analogWrite ====<br />
Le code se trouve dans le menu Exemple/Basics/Fade.<br />
<br />
'''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 !<br />
<br />
TODO: pretty print schéma/montage breadboard & pic<br />
<br />
'''Le code source:'''Regardons maintenant le code source:<br />
* 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<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** application de la valeur actuelle de luminosité (brightness) sur la led<br />
** mise à jour de la luminosité, par un petit incrément/décrément (fadeAmount peut être positif... ou négatif!)<br />
** mise à jour de l'incrément/décrément: on change son signe pour varier alternativement de maximum à minimum et inversement.<br />
** un petit délai pour voir les variations<br />
<br />
<br />
TODO: pretty print source code Fade<br />
<br />
==== Défi 6 : fade & RGB ====<br />
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 !<br />
<br />
=== Micro projet: feu tricolore ===<br />
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.<br />
<br />
Remarque: on peut utiliser le montage tout fait "feux de circulation lab". TODO: créer page & lien.<br />
<br />
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.<br />
<br />
TODO: feu trivial: pic montage<br />
<br />
TODO: feu trivial: code source "solution"<br />
<br />
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 !<br />
<br />
== Lire l'état d'entrées ==<br />
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.<br />
<br />
=== Bouton et entrée digitale (au choix, 0v ou 5v) ===<br />
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".<br />
<br />
<br />
==== Exemple "Button" ====<br />
Le code se trouve dans le menu Fichier/Examples/Digital.<br />
<br />
'''Le montage:''' TODO description du montage: gnd, SW, résistance pulldown.<br />
<br />
TODO picture: fritzing schéma<br />
<br />
'''Comprendre le schéma:''' rôle de la pulldown... et pullup.<br />
<br />
TODO picture: role de pulldown/pullup/tensions appuyé/non appuyé<br />
<br />
'''Le code:'''<br />
* 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.<br />
* on va utiliser une variable (buttonState) pour mémoriser l'état du bouton : on la déclare.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient plusieurs choses:<br />
** lecture de l'état de la pin 2 grâce à la fonction [https://www.arduino.cc/en/Reference/DigitalRead digitalRead]<br />
** en fonction de l'état de la pin 2 enregistré dans la variable buttonState: éteindre ou allumer la led L.<br />
<br />
==== Défi 1: changer le fonctionnement ====<br />
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) ?<br />
<br />
TODO: détailler l'énoncé du défi.<br />
<br />
Réponse: structure du code<br />
* Lire l'entrée<br />
* prendre des décisions<br />
* appliquer les sorties.<br />
<br />
Désolé pour la mise en page (en attente de pretty print wiki) :<br />
<br />
<code><br />
int buttonState = HIGH;<br />
int buttonState_old = HIGH;<br />
int ledState = HIGH;<br />
<br />
void setup() {<br />
pinMode(button_pin, INPUT_PULLUP);<br />
pinMode(led_pin, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
buttonState = digitalRead(buttonState); // on lit l'entrée<br />
if((buttonState == LOW) && (buttonState_old == HIGH)) { //appui bouton?<br />
if(ledState == HIGH) { //la led était allumée, on l'éteint<br />
digitalWrite(led_pin, LOW);<br />
ledState = LOW;<br />
}<br />
else {<br />
digitalWrite(led_pin, HIGH);<br />
ledState = HIGH;<br />
}<br />
}<br />
<br />
delay(100); // permet de faire un debounce: on verra plus tard ce que ca veut dire.<br />
}<br />
</code><br />
<br />
==== Défi 2: menu simple par durée d'appui ====<br />
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.<br />
<br />
Exemple d'interface : différencier les appuis longs ou courts permet d'augmenter ou de diminuer la luminosité d'une led.<br />
<br />
En pratique: analogWrite/Fade, si appui <1s, réduire intensité de 20%, si appui >1s, augmenter de 20% (entre 0 et 100%)<br />
<br />
<br />
==== Défi 3 : menu simple par comptage d'impulsions ====<br />
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.<br />
<br />
Exemple d'interface : compter le nombre d'appuis successifs/détecter doubleclic.<br />
<br />
* toggle avec deux leds? +/- vitesse? analogWrite/Fade?<br />
<br />
==== Notion de rebond ====<br />
Meta: Exemple Input->Serial et rebonds?, avec le port serie, fait à moitié un debounce... mais à vérifier. Sinon, pratique pour voir le rebond!<br />
<br />
Meta: comment amener le rebond? Defi 3: compter le nombre... et ca fail?<br />
<br />
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].<br />
<br />
Meta: est-ce qu'on voudrait pas introduire millis() ici? Permet de faire des trucs archi cool genre un fréquencemetre, un pseudo scheduler, ... <br />
<br />
Attention, piège du bounce (ou rebond, en francais).<br />
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.<br />
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.<br />
<br />
<br />
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.<br />
<br />
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.<br />
<br />
<br />
TODO: ajouter picture pour comprendre le debounce.<br />
<br />
<br />
Voir par exemple: https://www.arduino.cc/en/Tutorial/StateChangeDetection<br />
<br />
<br />
Conclusion: meme si tout cela reste encore rudimentaire, on a vu une chaine complete:<br />
* Entrée: appui(s) bouton<br />
* Traitement: selon la logique que l'on décrit avec notre programme, le microcontroleur va avoir un comportement different<br />
* Sortie: allumer ou éteindre une LED<br />
<br />
Voyons maintenant des entrées/sorties encore plus cool ! => OK! On peut mesurer des trucs mieux que juste marche/arret.<br />
<br />
=== Potentiomètre et entrée analogique (mesure entre 0v et 5v) ===<br />
C'est bien les boutons, mais pas assez: potard. Sur le joy, position x et position y.<br />
<br />
==== Exemple "AnalogInput" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma:''' pont diviseur de tension... mesure de résistance par mesure de tension. On ne sait QUE mesurer des tensions!<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** la pin 13 (ledPin) est une sortie.<br />
** on ne déclare pas d'entrée Analog!<br />
* on se fait des variables: sensorValue.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** utiliser la valeur lue comme paramètre de la fonction ''delay'' dans l'exemple Blink<br />
<br />
TODO: pretty print source code AnalogInput<br />
<br />
==== Défi : potard vers fade ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
Ici, relier à Fade.<br />
* Relation linéaire<br />
<br />
Réponse: bla bla code.<br />
<br />
==== Défi : potard roulette russe ====<br />
TODO: texte.<br />
<br />
Encore une fois: c'est à notre programme de decider ce que veut dire "bouger tel bouton" ou "déplacer le potentiometre".<br />
<br />
* Relation seuil... et notion d'hysteresis.<br />
<br />
Réponse: bla bla code.<br />
<br />
=== Microprojets: retour aux vieux codes, coffre fort ===<br />
Note: toujours bien sauvegarder et ranger chacun de nos codes... la preuve, ils vont servir à nouveau ici!<br />
<br />
Revisitons nos anciens codes:<br />
* reprendre le morse, et changer la vitesse de defilement (difficile/nécessite un code bien structure).<br />
* 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...).<br />
* défi: simuler le vent/led comme flame (nécessite d'aller chercher random dans la reference)<br />
* menu avec bouton, joystick... à préciser :P<br />
<br />
TODO: détailler les énoncés, donner les réponses code et montage<br />
<br />
== Communication avec le PC ==<br />
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...<br />
<br />
=== Communication Arduino -> PC ===<br />
Permet de remonter des informations, des mesures...<br />
<br />
==== Exemple "AnalogInOutSerial" ====<br />
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.<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial..? notions (baudrate, moniteur série) à la place?<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** on ne déclare pas d'entrée Analog!<br />
** D13 est une sortie.<br />
* on se fait des variables: sensorValue et outputValue<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** mesurer la valeur de la tension sur la pin A0 avec analogRead TODO lien ref<br />
** map: pour changer la dynamique. Indispensable ici!<br />
** Serial.print de chaine fixe.<br />
** Serial.print de variable.<br />
<br />
<br />
TODO: pretty print source code AnalogInSerialOut<br />
<br />
==== Défi : afficher autre chose que la valeur brute? ====<br />
*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 <br />
*Par exemple, du "filtrage": lorsqu'on regarde les valeurs defiler, on constate que ce n'est pas très précis/stable.<br />
<br />
==== Défi : serial et debug ====<br />
*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...<br />
<br />
=== Communication PC -> Arduino ===<br />
Envoyer des commandes et des infos à l'Arduino depuis le PC!<br />
<br />
==== Exemple "SerialInAction" ====<br />
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<br />
<br />
'''Le montage:''' TODO frizting.<br />
<br />
'''Comprendre le schéma/installation:''' TODO rien de spécial/nouveau...? voire rien du tout: L/D13<br />
<br />
'''Le code source:'''<br />
* la fonction setup(), exécutée au démarrage de la carte, permet de faire tous les paramétrages requis:<br />
** on initialise le module Serial avec la valeur de baudrate (vitesse de comm') à 9600.<br />
** D13 est une sortie.<br />
* la fonction loop() est ensuite exécutée en boucle. Elle contient XXX instructions:<br />
** vérification si données dispo avec fonction TODO ref<br />
** switch TODO ref pour choisir l'action selon le caractere recu.<br />
<br />
<br />
TODO: pretty print source code custom exemple:<br />
<br />
TODO: header comment<br />
byte inByte;<br />
<br />
void setup() {<br />
Serial.begin(9600);<br />
pinMode(13, OUTPUT);<br />
}<br />
<br />
void loop() {<br />
if(Serial.available()>0) {<br />
inByte = Serial.read();<br />
switch(inByte) {<br />
case 'a':<br />
digitalWrite(13, HIGH);<br />
break;<br />
case 'e':<br />
digitalWrite(13, LOW);<br />
break;<br />
}<br />
}<br />
}<br />
<br />
==== Défi : piloter plusieurs leds ====<br />
TODO texte et redécoupage.<br />
*exemple: pilotage RGB<br />
<br />
==== Défi : piloter Fade ====<br />
TODO texte et redécoupage.<br />
*exemple: valeurs/paramètres de fade<br />
*exemple: clignotements différents, eg trig de séquences<br />
<br />
==== Défi : set de valeurs..? ====<br />
*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...)<br />
*exemple de parsing de chaine..? probablement trop compliqué par contre on peut faire +/-/set comme exemple bras robot!<br />
<br />
=== Microprojets: XXX ===<br />
Terminal morse (avec potard pour vitesse) Autre chose de plus phunky?<br />
<br />
backdoor paramétrage central intersection<br />
<br />
== Pour aller plus loin ==<br />
TODO texte...<br />
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.<br />
<br />
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!<br />
<br />
On fait le tour de ceux dans le kit découverte... et il en restera 100 fois plus à découvrir ;)<br />
<br />
=== Capteurs de température et de lumière ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
Jouer avec pont diviseur de tension, et voir que peu importe ce qui fait la tension, coté code, c'est kifkif bourricot!<br />
<br />
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).<br />
<br />
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.<br />
<br />
IMAGE: vue schématique d'un potentiometre... pont diviseur de tension, fonctionnement identique si on prend notre capteur et une résistance fixe.<br />
IMAGE: calcul de la relation d'un pont diviseur de tension: loi d'ohm, loi des mailles.<br />
<br />
<br />
Note: choix de la résistance dans pont div selon capteur, et calibration avec serial monitor.<br />
<br />
Comment on choisit la résistance à coté? ca va marcher avec différentes valeurs... plus ou moins bien.<br />
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.<br />
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.<br />
<br />
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<br />
<br />
==== Exemple : capteur de lumiere ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
==== Exemple : capteur de température ====<br />
*schema: pont diviseur de tension. Expérimentation/Serial pour trouver la valeur optimale de résistance, ou bien datasheet...<br />
*code example, applis marrantes: tous les exemples précédents avec potard marchent ici sans modif ou presque.<br />
<br />
<br />
=== Buzzer et sons ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
==== Exemple : cri de la victoire ====<br />
Code exemple de tone<br />
<br />
==== Défi : morse en audio ====<br />
On pourrait avoir le terminal Morse en audio plutot que sur la led.<br />
<br />
==== Défi : theremine ====<br />
On veut faire un synthétiseur/thérémine avec le joystick/capteur de lumiere.<br />
<br />
=== Microservomoteur et mouvement ===<br />
TODO: meme structure que séquence: exemple de code, montage, compréhension, défis.<br />
<br />
<br />
==== Exemple: swipe ====<br />
analyse, comme d'hab.<br />
<br />
==== Exemple: knob ====<br />
analyse, comme d'hab... est-ce vraiment nécessaire? Sinon seulement "voir aussi" dans swipe.<br />
<br />
==== Défi : trappe aération serre ====<br />
capteur de température et ouverture trappe ventilation serre, hysteresis, etc.<br />
<br />
=== Microprojet: poubelle intelligente ===<br />
capteur de lumière/capteur de proximité => poulie, servomoteur<br />
<br />
=== Microprojet: bras robot ===<br />
pilotage par potards et par serial port du kit bras robot 4 axes.<br />
<br />
= Conclusion =<br />
Cette formation a permis de faire nos premiers pas avec un microcontrôleur, en utilisant Arduino:<br />
* piloter des sorties (digitales et analogiques),<br />
* lire l'état d'entrées (digitales et analogiques),<br />
* communications avec le PC (dans les deux sens)<br />
* capteurs et actionneurs sympa.<br />
<br />
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.<br />
<br />
D'ailleurs, quel projet allez vous réaliser maintenant ? Libre à vous de décider ! Les possibilités sont très vastes.<br />
<br />
== la suite ==<br />
* 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?)<br />
=> quel type de projet voulez vous faire? quels capteurs/actionneurs voudriez vous découvrir?<br />
<br />
* Améliorer votre compréhension des microcontrôleurs, de l'électronique numérique, de l'informatique embarquée, ...<br />
=> Qu'est ce que vous voulez apprendre de plus/approfondir?<br />
<br />
* notes/laissés en exercices:<br />
** grapher les caractéristiques capteur de température, de lumière.<br />
** faire marcher le buzzer et le servomoteur SANS appel à la librairie<br />
** -> probablement que ce sont des séances de TP "découverte de bidule: aujourd'hui le servomoteur".<br />
<br />
* projets:<br />
** bouilloire d'eau avec asservissement température<br />
** clignotants vélo+système d'éclairage "simple"<br />
** ouverture auto de couvercle de poubelle (servomoteur et capteur de lumiere)<br />
<br />
== retours sur la formation ==<br />
* Discutons de la formation: qu'est-ce qui a bien marché? pas bien marché? Que faut il garder, supprimer, ajouter?<br />
* Appropriez vous le contenu. Sauriez vous animer la formation vous meme? expliquer ce que vous venez d'apprendre à quelqu'un d'autre?<br />
<br />
A vous la parole: remplissez la fiche d'évaluation.<br />
Rangeons le materiel et la salle pour les suivants!<br />
<br />
= Fourre tout sur la suite =<br />
Quelques notes sur les sujets qu'on peut avoir envie d'aborder...<br />
<br />
Dans la série purement SW... Fonctions additionnelles:<br />
* millis, micros ; structure if(time_current>time_last+time_period)<br />
* attachinterrupt<br />
* switch case/FSM<br />
* asservissement<br />
<br />
Autres topics SW:<br />
* RT OS (eg scheduler, mecanismes usuels)<br />
* bootloader<br />
* USB (sur 32u4)<br />
* lib writing/packaging<br />
* real debugging (eg debugwire)<br />
* real toolchain (eg avrstudio, eclipse)<br />
<br />
Autres topics HW:<br />
* fork board</div>Clément