Semaine 12 : Internet des Objets (1/2)

Libérer l’Arduino sans perdre notre oeuvre

Ce qui est bien avec l’Arduino, c’est qu’il est très facile d’essayer un concept, tester une idée et même créer un prototype de projet. Jumelé avec la platine d’expérimentation et soutenu par les bibliothèques officielles et contribuées même l’UNO devient une base de développement assez puissante pour un grand nombre de projets. Le souci - surtout si, comme moi, vous avez beaucoup d’idées à tester - c’est qu’il faut démonter chaque expérimentation avant d’en commencer une autre. Cela me rappelle mon enfance et les heures passées à jouer avec le mécano : je n’appréciais pas du tout de démonter la dernière création afin d’avoir des pièces disponibles pour la suivante. Parfois on a tout simplement envie de garder notre création - surtout quand c’est quelque chose de ludique et/ou d’utile.

Nous allons regarder ensemble les étapes, et les outils, nécessaires pour créer un montage permanent à partir de notre prototype fonctionnel construit avec l’Arduino. Je ne parlerai que de la version ATMEGA328, le coeur de l’Arduino UNO.

Ce module d’instruction va être encore plus dense que d’habitude : j’anime un cours similaire (plateformes PIC et Arduino) sur plusieurs jours ! Donc on s’accroche et en avant !

Point de départ

Le point de départ est un microcontrôleur ATMEGA328. Pour les montages "Do It Ourselves" (fait nous-mêmes), la version P-DIP est la plus pratique. Il s’agit d’une puce avec 28 pattes. On peut l’insérer (délicatement car les pattes sont fragiles) directement sur une platine d’expérimentation. Comme ici :

Il est possible de faire fonctionner ce microcontrôleur sans ajouter d’autres composants au tour, mais pour un maximum de compatibilité avec l’environnement Arduino UNO il est conseillé d’ajouter un quartz 16MHz et ses deux condensateurs. Mais je m’avance déjà trop… Car notre microcontrôleur est livré complètement vide. Comme un enfant nouveau-né il ne sait ni parler, ni comprendre ce qu’on lui dit. Pour être en mesure de téléverser un Sketch Arduino, cette puce a besoin d’une séance de rattrapage - un peu comme dans matrix - pour qu’il comprenne le langage Arduino. Dans le jargon parfois un peu barbare de l’informatique on parle de flashage. L’idée c’est d’installer un petit logiciel permanent dans le microcontrôleur, lui permettant de dialoguer avec un autre ordinateur via sa liaison série. Il existe des appareils spécifiques pour cette tâche (on parle de ICSP ou In-Circuit-Serial-Programming) mais notre Arduino polyvalent peut aussi nous servir de 'flasheur’. Voici donc la première étape de notre parcours : préparer le microcontrôleur.

Flashage : Avec ou sans quartz ?

C’est une question importante qu’il faut se poser tout de suite car le logiciel que nous allons télécharger est différent pour les deux cas.  Sans le quartz, il est possible de faire fonctionner ce microcontrôleur avec son horloge interne qui est réglée à l’usine pour tourner à 8MHz.  L’Arduino UNO est équipé d’un quartz de 16MHz, donc deux fois plus rapide. Mais le quartz n’est pas gratuit : non seulement il a un prix, mais aussi il prend de la place et, surtout, deux lignes d’entrée/sortie. Regardons l’image suivante : 

Cette image, qu’il faut garder précieusement à coté de vous pendant ce projet, nous montre les branchements de l’ATMEGA328 et les équivalences Arduino UNO. Notez que l’ATMEGA168 et l’ATMEGA328 partagent la même configuration d’entrées et sorties. Si on regarde les pattes 9 et 10 on voit que, sur l’Arduino, elles sont connectées sur le quartz (crystal).  Mais ce sont des broches d’entrée sortie comme les autres. Si nous n’avons pas besoin de faire fonctionner le microcontrôleur à 16MHz (et c’est rarement le cas), nous pouvons "récupérer" ces deux broches pour autre chose. Dès que nous avons pris notre décision, préparons le bloc opératoire pour le flashage.

Version 16MHz (avec quartz)

Il faut faire un montage comme ceci¹ :

Les branchements au microcontrôleur sont des plus simples : l’alimentation en +5v et 0v (les deux côtés, notez bien), le quartz avec ses deux condensateurs, et une résistance de "pull-up" pour une fonction de remise à zéro (reset) pilotée. La liaison de communication est une liaison série similaire à l’interface I²C que nous avons étudiée la semaine dernière. L’idée de ce montage est d’utiliser l’Arduino comme programmateur. Voici comment procéder :

1. Quand tout est bien câblé, ouvrir l’environnement Arduino et chercher un Sketch qui s’appelle "ArduinoISP" sous Exemples.
2. Téléverser ce Sketch dans l’Arduino.
3. Allez dans le menu Outils (Tools) et chercher l’option Programmateur, puis sélectionner "Arduino as ISP".
4. Toujours dans le menu Outils, cliquer sur l’option "Graver la séquence d’initialisation".  Les LEDs Rx et TX de l’Arduino vont clignoter pendant plusieurs secondes puis, si tout va bien, le message "Gravure de la séquence d’initialisation terminée" sera affiché.
5. Le microcontrôleur est prêt pour le service. Notez bien qu’il ne fonctionnera QUE si le quartz et les deux condensateurs sont branchés. Vous pouvez maintenant procéder à l’étape Premier essai.

Version 8MHz (sans quartz)

Avant de vous montrer le câblage pour le programmateur, il faut que je vous explique quelques détails. Pour la version 16MHz, dès que le microcontrôleur est 'flashé' il se comporte exactement comme un Arduino UNO - car les paramètres de fonctionnement sont les mêmes. Pour la version 8MHz, par contre, certains paramètres devraient changer. La configuration de l’horloge interne et l’attribution des broches 9 et 10, pour commencer. Non seulement le code d’initialisation est différent, mais pour l’environnement de développement cette bestiole n’est plus un Arduino UNO - et donc la compilation et le téléversement des Sketchs sont aussi modifiés. Heureusement, l’environnement est relativement facile à personnaliser. Nous avons besoin de deux nouveaux fichiers, à installer une fois pour toute, pour que notre 'mutant' soit accepté parmi les plateformes Arduino. Le premier fichier contient les paramètres pour les étapes de flashage, et de téléversement. Le deuxième fichier contient les définitions pour le microcontrôleur sans quartz et avec les deux broches d’entrée/sortie supplémentaires. Voici comment les installer :

• Téléchargez ce fichier Arduino_breadboard.zip, et le décompressez dans un dossier nommé "hardware" dans votre dossier principal "sketchbook". Voici nos deux fichiers. Le fichier boards.txt va rester là où il se trouve, l’autre fichier est à installer dans l’environnement Arduino.
• Cherchez le dossier principal de votre installation Arduino. Vous aurez besoin des droits d’administrateur car ce dossier est probablement sous /usr/share, par exemple, sous linux. Sous windows, il me semble (car je n’ai pas une version windows chez moi) que c’est sous \Program Files…
• Descendez l’arborescence de ce dossier jusqu’à …/hardware/arduino/variants. Dans le dossier variants il faut créer un nouveau dossier "breadboard" (sans majuscules).
• Déplacer le fichier pins_arduino.h que vous avez décompressé tout à l’heure dans ce nouveau dossier breadboard. (sous linux : vérifier les droits de lecture…)
• Ça-y-est ! Il ne reste qu’à fermer et à redémarrer le logiciel Arduino.

Pour vérifier que les modifications ont étés prises en compte, regarder dans le menu Outils / Type de carte : à la fin de la liste vous devriez voir "ATMEGA328 on a breadboard (8MHz…"

Voici le câblage pour programmer notre microcontrôleur 8MHz :

Ben, c’est pareil que l’autre - sauf qu’il n’y a plus le quartz ! Ah si, la résistance a aussi disparu… Il vaut mieux la mettre, cette résistance, si possible. Voici la procédure de flashage :

1. Quand tout est bien câblé, ouvrir l’environnement Arduino et cherchez un Sketch qui s’appelle "ArduinoISP" sous Exemples.
2. Téléversez ce Sketch dans l’Arduino.
3. Allez dans le menu Outils (Tools) et chercher l’option Programmateur, puis sélectionnez "Arduino as ISP".
4. Maintenant, et c’est très important, il faut changer le type de carte : sélectionnez "ATMEGA328 on a breadboard (8MHz…"
5. Toujours dans le menu Outils, cliquez sur l’option "Graver la séquence d’initialisation". Les LEDs Rx et TX de l’Arduino vont clignoter pendant plusieurs secondes puis, si tout va bien, le message "Gravure de la séquence d’initialisation terminée" sera affiché.
6. Le microcontrôleur est prêt pour le service.

Premier essai

Nous voilà avec un microcontrôleur fraîchement flashé (on dirait une publicité pour dentifrice). Comment vérifier si ça marche ? Il faut téléverser un programme dedans ! Mais comment ? La sortie de notre PC de développement c’est un câble USB. Le microcontrôleur tout nu n’a rien pour communiquer. Là encore, deux solutions sont possibles :

• Modifier notre Arduino pour que notre microcontrôleur prenne la place du 'vrai' ;
• Utiliser une interface USB/Série .

Téléversement avec l’Arduino

Je ne vous conseille pas cette opération si l’Arduino que vous avez devant vous n’est pas le vôtre ! Car on va enlever le microcontrôleur !  Et j’ai déjà dit que les broches sont fragiles… Si vous êtes dans un Fablab ou autre endroit génial de ce genre, demander à votre GO (gentil organisateur) s’il n’a pas une interface série à vous prêter.

Deuxième avertissement : les composants électroniques sont TRES sensibles aux décharges électrostatiques. Ne travaillez pas avec l’électronique si vos vêtements sont en fibres synthétiques et que vous entendez des crépitements quand vous bougez ! Le microcontrôleur sorti de la carte est très vulnérable : il faut l’insérer dans de la mousse conductrice (mousse noire) ou, à défaut, dans un morceau de papier alu replié plusieurs fois.

Les avertissements derrière nous, voila l’étape un peu critique : il faut enlever le ATMEGA328 de la carte Arduino. Le souci c’est qu’il faut soulever la puce sans en tordre les pattes. Procédez avec précaution, sans précipitation. Dans un Fablab, ils auront peut-être le vrai outil (extracteur), mais chez nous il faut chercher un tournevis fin, genre tournevis de joaillier. Avant d’enlever le microcontrôleur, marquez d’un point de blanc correcteur ou similaire afin qu’on ne le confonde pas avec notre microcontrôleur à nous… En commençant par le côté opposé aux connecteurs d’alimentation / USB, passez le tournevis à plat entre la puce et son support - sur toute la longueur de la puce.  Soulevez un peu (1 à 2mm). Sortir le tournevis et maintenant procédez de même de l’autre coté. Continuez ainsi jusqu’à la libération de la puce. Redressez (doucement) les éventuelles pattes tordues, et placer le microcontrôleur dans la mousse conductrice.

Deux possibilités se présentent à nous : on peut câbler l’interface entre l’Arduino désormais "brain dead" et notre platine d’expérimentation, ou on peut insérer notre microcontrôleur sur l’Arduino à la place du 'vrai’. Cela vaut aussi pour la version 'mutante' à 8MHz. Sachant que si on prend la 2ème option, il faut refaire l’étape stressante de enlèvement de puce une deuxième fois !  Voici le schéma de câblage pour l’option "platine" :

C’est assez simple, et peut-être plus sûr que de risquer d’endommager les pattes de notre microcontrôleur…

Ouvrir l’environnement Arduino. Si nous travaillons avec le microcontrôleur à 8MHz, il ne faut pas oublier de changer le type de carte dans le menu Outils. Téléversez le Sketch 'Blink' (Exemples / 01.Basics / Blink). Si vous avez inséré votre microcontrôleur sur la carte Arduino vous devez voir la LED sur la broche 13 clignoter. YES ! Ça marche !

Et sur la platine ? Mais oui, il faut ajouter la LED (et sa résistance !) - mais sur quelle broche ? Allez, la réponse est plus haut. Je vous ai même dit qu’il fallait la garder proche de vous…. Oui, l’image de "pin mapping". Sur la carte Arduino, la LED est branchée sur le connecteur 13. Cherchez "digital pin 13" sur l’image et vous verrez que cela correspond à la broche 19 du microcontrôleur². Il suffit de brancher notre LED entre la broche 19 et 0v/GND. Magique ! Aujourd’hui Blink, demain le monde.

Téléversement à l’aide d’une interface série

Plusieurs sortes d’interfaces USB / Série existent, elles appartiennent à deux grosses catégories : les 'simples’, ne comportant pas d’autres signaux que Rx et Tx, et les autres - plus évoluées. Certaines sont même pré-configurées pour fonctionner exactement comme l’interface intégrée dans l’Arduino : c’est la solution la plus simple (mais, forcement, la plus chère). Les versions 'simples’ fonctionnent bien mais pour ceux qui ont connu les Arduinos d’antan… ils vont retrouver leur jeunesse car il faut 'resetter' le microcontrôleur manuellement afin de lancer le téléversement. Les interfaces plus évoluées, équipées d’une broche DTR ou carrément une ligne 'reset’, souvent appelées FTDI, nous facilitent la tâche.

Voici le câblage pour la version 'simple' :

Le bouton câblé sur la broche 1 est là pour faire 'reset’. C’est un coup de main à trouver, mais quand on lance le téléversement il faut avoir le doigt sur le bouton et les yeux rivés sur le programme Arduino : dès l’instant où la compilation est terminée (la taille de notre Sketch est affichée) il faut appuyer sur le bouton 'reset’. Si tout va bien le programme est chargé dans le microcontrôleur. Essayez avec le Sketch Blink.

Si vous avez une interface USB / Série évoluée, avec une sortie DTR, voici comment la câbler :

Les plus avertis d’entre vous remarqueront le montage condensateur/diode sur la broche 1. J’ai parlé de ce montage dans le Wiki intitulé "Diodes et condensateurs, suite et fin". C’est le circuit de détection d’un flanc descendant. La diode joue un rôle important : empêcher la tension sur la broche 1 de dépasser de trop les +5v maxi autorisés. Avec ce montage, le reset pour le téléversement est automatique, et ce montage se comporte exactement comme un vrai Arduino.

Alimentation

Avec l’option liaison série (avec adaptateur ou avec la carte Arduino) l’alimentation en 5v de montage est assurée. Mais si le but est de faire un appareil autonome (comme l’Arduinomètre), il faut résoudre le problème de l’alimentation. Comme toujours, nous avons plusieurs solutions. Je vais vous parler de deux solutions similaires à base de régulateurs de tension. Mais, d’abord, quelques rappels.

Le microcontrôleur a besoin d’une alimentation stable à environ 5v. Les variations de tension sont néfastes car ils perturbent le bon fonctionnement du processeur. Malheureusement 5v sont difficiles à fournir avec des piles et la tension fournie par les piles n’est pas très stable. Donc, au lieu d’essayer de faire une pile qui fournit exactement 5v, on utilise une pile d’une tension supérieure et on réduit la tension à 5v. Mais comment ? Les premiers chapitres du cours d’électronique nous ont montré qu’une résistance peut servir pour faire chuter la tension. Il suffit d’avoir une intensité stable et on peut calculer la résistance nécessaire pour obtenir la chute de tension voulue. Si vous avez suivi le Wiki sur les diodes Zener vous aurez vu qu’il est difficile d’avoir une intensité stable avec un montage microcontrôleur : le processeur en lui-même ne consomme pas beaucoup - 10mA en tout. Mais si on allume des LEDs à 20mA chacune on peut avoir une intensité qui varie du simple au quadruple dans le temps : impossible de calculer une valeur de résistance dans ces conditions-là.  En plus, nous avons aussi vu que cette chute de tension à travers une résistance est un gaspillage d’énergie car ça chauffe la résistance (ce qu’on appelle l’effet Joule). C’est pourquoi le régulateur de tension est vraiment la seul possibilité pour nos montages.

Le 7805

Avec le NE555, le 7805 fait vraiment partie des vénérables ancêtres de l’électronique moderne. Même si ce régulateur existe en une multitude de formats, et que d’autres types de régulateurs existent avec de meilleures spécifications, il reste indémodable ! Deux versions de ce régulateur sont intéressantes pour nous : le 7805CV en format TO220 (format transistor de puissance) qui peut gérer une intensité d’un ampère maximum ; et le 78L05 en boîtier TO92 (format transistor normal) pour les intensités de 100mA maximales. Les deux versions TO92 et TO220 coûtent environ 0,50€ pièce. Le brochage :

Et le schéma de câblage :

Les deux condensateurs devraient se trouver le plus près possible du régulateur. Pour que les régulateurs 78xx fonctionnent correctement, la tension d’entrée devrait être supérieure d’au moins 2V de plus que la tension de sortie. Il faut veiller au refroidissement, surtout avec le TO220 aux intensités approchant 1A.

Il existe aussi un équivalent en version 'faible chute de tension’, le LM2940, par exemple. Les versions 'faible chute de tension' se prêtent bien aux montages avec alimentation à pile. Ils ont besoin, par contre, d’un condensateur de forte valeur (22uF minimum) à leur sortie.  Attention car certains de ces régulateurs n’ont pas le même brochage (pinout) que le 7805 - consulter la documentation technique !

Les platines

On trouve aussi les petites platines régulateurs - d’une taille de quelques mm² - qui peuvent gérer jusqu’à 1A avec une assez faible chute de tension. Leur utilisation est identique : une entrée, une connexion 0v et une sortie régulée. Les prix varient de 1€ à plusieurs Euros.

Et maintenant ?

Nous avons vu beaucoup de choses, et il est possible que nous ayons perdu de vue notre objectif : sauvegarder un montage ou un prototype - ou carrément le transformer en produit fini. Les étapes parcourues jusqu’ici sont les étapes préliminaires nécessaires pour la préparation d’un microcontrôleur ATMEGA328, et les montages possibles pour la suite : la programmation avec l’environnement Arduino. Pour terminer je voulais prendre un exemple concret : mon Arduinomètre avec afficheur LCD. C’est un montage encore simple, mais suffisamment complet pour nous fournir de bonnes bases pour des projets plus ambitieux. Voici le montage d’origine, avec Arduino et platine :

Si, armé de mon image "pin mapping" je dessine le schéma qui correspond aux branchements sur le ATMEGA328, cela donne ceci :

Et le montage avec Fritzing :

C’est pas si difficile, n’est-ce pas ?

Mais maintenant je veux créer une platine permanente : un circuit imprimé. A la maison, il est possible de faire des platines simple-face de bonne qualité avec des moyens modestes. Nous n’avons pas parlé de ce sujet, mais tant qu’on a Fritzing ouvert, voici ce que cela donne :

Ici, on commence à voir le souci pour cette dernière étape. J’ai déjà placé le plupart des composants aux endroits adaptés, mais j’ai plusieurs pistes qui se croisent. (Regardez les lignes pointillées).  Pour ce montage ce n’est pas très méchant et il est toujours possible de poser des 'cavaliers’ : des fils qui sont posés comme s’ils était des composants et qui servent à 'sauter' des pistes. Mais d’autres astuces sont aussi possibles. Il n’y a pas grand chose de branché sur notre microcontrôleur : un grand nombre de ces broches ne sont pas connectées. Si on change les définitions de brochage dans notre Sketch, il est tout à fait possible de faire en sorte que les pistes ne se croisent plus.

Je vous laisse le fichier Fritzing ici et le Sketch de l’Arduinomètre d’origine ici

• vous pouvez jouer avec les deux pour trouver une solution.

Bénéfices et inconvénients de la version 8MHz

Dernier petit mot au sujet de la version 8MHz. Nous avons vu que l’inconvénient majeur c’est qu’il faut ajouter des fichiers de paramètres dans l’environnement Arduino. Cela n’est pas trop contraignant, mais il faut garder les deux fichiers avec vous, sur une clef USB par exemple, si jamais vous partez en "voyage" avec votre montage - dans un Fablab, par exemple : car sans les deux fichiers installés, impossible de compiler ou téléverser des Sketchs dans le microcontrôleur 8MHz. L’autre inconvénient est que le processeur tourne plus lentement. Mais, franchement, il est quand-même rare que cette différence soit vraiment marquante car, dans la grande majorité des cas, notre programme reste dans les boucles d’attente : soit les delay() que nous avons codées nous-même, soit les attentes pour l’afficheur LCD, pour la liaison série, pour le I²C et j’en passe…

Et les bénéfices, alors ? En voici quelques-uns 

• C’est moins cher (le prix du quartz);
• Moins de place prise sur la platine ou sur le circuit imprimé;
• DEUX ENTREES / SORTIES EN PLUS ! La broche 9 devient "digital pin 20" (entrée ou sortie au choix); La broche 10 devient "digital pin 21" (entrée ou sortie au choix). [Pour les puristes il s’agit des E/S PORTB6 et PORTB7, qui n’existent pas sur l’Arduino UNO]
• Plus de flexibilité pour les montages.

Voilà !

Nous avons fait un grand chemin ensemble. J’espère qu’à travers les différents modules au fil des semaines, je vous ai donné le goût de vouloir expérimenter, apprendre et faire vos propres réalisations.  Passez un bon été et peut-être à bientôt dans un Fablab ou une autre animation.

Internet des objets

Merci d’avoir regardé cette vidéo. Celle-ci constitue une brève introduction à l’internet des objets et son application avec Arduino. Nous vous invitons maintenant à réaliser votre premier montage connecté. Aussi, il est (vraiment) recommandé de lire les références proposées ici :

Références

• Documentation de la librairie Ethernet par Xavier Hinault
• Cours sur l’architecture d’Internet

Merci au FabLab Lannion pour ce cours

TP à faire pour la semaine 13

Ça se corse cette semaine !

À partir des fonctions vues dans la vidéo et de vos connaissances acquises lors des précédentes semaines, l’objectif de ce TP sera d’allumer ou éteindre les leds à partir d’un navigateur internet.

Vous devrez connecter votre arduino en filaire sur votre box via le shield Ethernet :

• Depuis un browser sur votre PC vous enverrez une requête http de la forme http://192.168.1.x?led=on ou http://192.168.1.x?led=off permettant respectivement d’allumer ou d’éteindre la LED
• Pré-requis: partir d’un TP précédent comme base pour l’allumage d’un LED, brancher le shield Ethernet, intégrer la librairie Ethernet (beaucoup d’infos ici).

 

Quelques indices

Vous aurez besoin de mobiliser toutes les compétences vues ces dernières semaines pour réaliser ce TP : 

• L’utilisation d’une sorties numériques 
• L’utilisation de la librairie Ethernet et de l’exemple WebServer.
• N’oubliez pas de modifier les adresses MAC et IP.
• Vous pourrez avoir besoin de la librairie String.h et notamment des fonctions : concat() et substring()

La correction (montage et code) sera donnée la semaine prochaine !

 

Bon courage (car il va en falloir) et bonne semaine,

L’équipe du MOOC