[Tuto KiCad] Concevoir un circuit imprimé partie 1: le schéma

Salut les poilus!

Il y a un bon moment ce ça (oh la vache oui, été 2012), j’avais écrit cet article sur Fritzing.

C’est vrai que Fritzing c’est bien. Mais dès qu’on doit utiliser des composants qui ne sont pas dans sa bibliothèque, c’est vite TRÈS lourd. Il faut créer le composant, créer son empreinte au format SVG, et disons-le franchement: les interfaces de création ne sont pas géniales et j’ai autre chose à faire que de passer une heure à créer un relais ou quoi que ce soit d’autre.

J’avais testé vite fait KiCad et j’avais vite abandonné car pour le coup, Fritzing était plus facile à prendre en main. Mais frustrant. Mais plus facile à prendre en main. Alors bon.

Récemment j’ai attaqué la conception d’un circuit imprimé sur lequel sont implantés:

  • Une Teensy 3.2
  • Un lecteur de carte MicroSD
  • Un écran OLED

Et connaissant Fritzing et ses limitations, je n’ai même pas osé le démarrer et je me suis mis sérieusement à KiCad.

Héééé ben franchement je vais vous dire:

  1. ce n’est pas si compliqué
  2. je relègue définitivement Fritzing au placard, en le remerciant pour les services qu’il m’a rendus.

Avec KiCad, on a un véritable outil de conception de circuits imprimés, avec aussi sa bibliothèque de composants (fatalement limitée), mais quel plaisir de pouvoir créer un nouveau composant en 5 minutes s’il n’existe pas dans la bibliothèque de base!

Le truc avec KiCad, c’est que la prise en main n’est pas hyper intuitive au tout départ. Mais une fois qu’on a pris le temps de comprendre les quelques concepts de base, c’est tellement bon… Et c’est ce que je vais vous expliquer ici.

Pour aller plus loin évidemment, il y a la documentation officielle de KiCad

Créer un projet

KiCad manipule plusieurs types de fichiers, selon la tâche à effectuer (typiquement les schémas électroniques et les implantations physiques de composants). Tous ces fichiers sont regroupés dans un répertoire de projet.

La première étape, quand on veut concevoir un circuit, et donc de créer un projet: Fichier/Nouveau projet/Nouveau projet, et nous l’appelerons tuto-dm.

Dans le répertoire, il crée automatiquement 3 fichiers: tuto-dm.pro, tuto-dm.sch et tuto-dm.kicad_pcb.

Créer le schéma électronique

Pour ce tuto, nous allons créer un circuit imprimé contenant un atmega128 (DIP), un driver de moteur pas à pas Pololu A4988, et disons une LED et sa résistance. Le but de ce tutoriel n’est pas de réaliser un projet fonctionnel, mais d’apprendre les bases de la conception dans KiCad.

On va donc maintenant rentrer dans le dur, et créer notre schéma. Pour cela, dans KiCad, double-cliquons sur tuto-dm.sch

Nous avons droit à un bel écran de dessin technique, avec un cartouche en bas (spéciale dédicace aux cours de techno du collège).

Deux barres d’outils : à gauche, des options d’affichage (j’ai envie de dire: rien à péter pour l’instant); à droite, ce qui va nous intéresser: la barre d’outils de dessin.

Parmi les outils, trois vont nous intéresser:

  • le triangle avec les signes + et – (oui, c’est un ampli op! Bonne réponse de l’amiral) permet de placer des composants sur le schéma.
  • le symbole de masse nous permet de placer des symboles de type « power », c’est à dire tout ce qui est relatif à l’alimentation.
  • le segment vert permet de placer des fils, autrement dit de relier les composants entre eux.

Petite note sur le déplacement dans la vue:

  • Clic milieu + déplacement de la souris: panning
  • Molette : zoom

Placement des composants

Cliquons sur l’icône « placer un composant », puis quelque part sur le dessin. Une fenêtre s’ouvre, pour nous demander quel composant insérer.

Dans le champ de filtre, nous allons taper ATMEGA328, et sélectionner le premier de la liste (ATMEGA328-AU) en double-cliquant dessus. On peut positionner le microcontrôleur avec la souris, et cliquer pour valider.

Plaçons maintenant notre led et sa résistance. KiCad est encore en mode « placer un composant », donc il suffit de cliquer quelque part sur le schéma pour rouvrir la fenêtre de sélection de composant.

Dans le filtre, tapons R, et double-cliquons sur le 1er résultat :R [Resistor]. Avant de positionner la résistance, on peut la faire pivoter en appuyant sur la touche R du clavier (Rotate). Mettons-la à l’horizontale, et plaçons la à côté de la pin PB1 de l’ATMEGA328.

Même topo pour placer la LED (LED_GENERIC), et nous allons la positionner à côté de la résistance. Si vous avez déjà placé un composant et que son sens n’est pas bon, pas de problème! Il suffit de positionner le curseur de la souris au-dessus (pas besoin de cliquer) et d’appuyer sur la touche R du clavier jusqu’à obtenir l’orientation correcte.

Normalement on devrait en être là:

Placement des alimentations

Pour KiCad, une alimentation est un composant spécial, accessible avec le bouton

On va commencer par placer les masses à côté de la led, et l’ATMEGA328.
Cliquer sur [], et chercher GND dans la liste. Placer les différentes masses, et répéter l’opération pour le 5V sur l’ATMEGA328.

Votre schéma ressemble à ça? Très bien.

Création de composants personnalisés

Ok, donc il ne nous manque plus que le Pololu A4988. Cliquons sur le schéma, puis dans le filtre: POLO… Ah non. A49… Non plus.
Aha, je vous ai bien eus hein 😀

Ce serait trop facile…

Bon, hé bien il ne reste plus qu’à le créer puisqu’il n’existe pas en standard! z’allez voir, ça n’a rien de méchant.

On va commencer par cliquer, dans la barre d’outils du haut, sur le bouton « Editeur de librairie – créer et éditer des composants »

Arrive une page blanche, sur laquelle nous allons pouvoir dessiner notre Pololu A4988 dans sa version schématique.

Cliquons sur le bouton « Créer un nouveau composant »

  • Nom du composant »: POLOLU_A4988
  • Référence par défaut: DRV (Totalement arbitraire. DRV = Driver)

Laissons les autre champs tels quels et cliquons sur OK.

A l’écrans, nous avons maintenant deux blocs de texte superposés, que nous allons arranger un peu.

C’est l’occasion d’apprendre comment déplacer des éléments dans KiCad!
Il suffit de placer la souris au-dessus du texte, et appuyer sur la touche M. A partir de là, on peut déplacer le composant avec la souris, et quand c’est bon, on clique. C’est tout 🙂

Avant de créer les connexions, on va juste ajuster la grille avec un clic droit, Sélection grille, et sélectionner 2.54mm.

Ok, maintenant créons les 16 connexions de notre A4988, en commençant par la rangée de gauche(de haut en bas), puis la rangée de droite(de bas en haut). Pour rappel, voici un Pololu A4988 dans son milieu naturel:

http://www.arduino-projekte.de

Sur la barre d’outils de droite, cliquons sur le bouton Ajouter des pins au composant , puis quelque part sur la page. Pas d’inquiétude pour le positionnement du composant par rapport à l’origine, on pourra le replacer plus tard.

Après avoir cliqué sur la page, une fenêtre s’ouvre et nous demande plus d’informations sur la pin à créer.
La première s’appelle ENABLE avec une barre au-dessus (pour dire que le driver est activé si elle est à zéro volt). Dans le champ nom pin, tapons ~ENABLE~, les ~ servant à afficher la barre au-dessus du texte.

Numéro de pin: 1
Orientation: Droite
Type: Entrée

Clic sur OK, clic sur la page et hop! La première pin est créée.
Et on enchaine avec les suivantes:

Nom: MS1
Numéro de pin 2

Nom: MS2
Numéro de pin 3

Nom: DIR
Numéro de pin 8

C’est bon?

Alors avant de tout casser, nous allons sauver ce composant.
Il faut d’abord créer une librairie qui va le contenir: cliquons sur « Sauver le composant dans une nouvelle librairie ». On va parcourir le disque jusqu’à trouver le répertoire de notre projet et sauver sous le nom « pololu_a4988.lib ». Au message qui suit, répondons OK, puis allons dans le menu Préférences/Librairies de composants. Dans la liste du haut, cliquer sur Ajouter, et sélectionner le fichier pololu_a4988.lib fraichement créé. Bien!

Cliquons enfin sur « Sélection de la librairie de travail », et dans le filtre: pololu. Valider en double cliquant sur pololu_a4988.

Là, on est bien!

Allez, on va créer les 8 pins de droite en commençant par en bas. Plus aucune difficulté maintenant! Pensez juste à changer l’orientation des pins 😉

Nous n’avons plus qu’à dessiner un rectangle autour du Pololu, ramener les textes à côté avec la touche M, sauver avec un petit Ctrl+S et hop! C’est terminé.

On peut fermer l’éditeur de composant et revenir à notre schéma principal. Maintenant, si on clique sur « Placer un composant », dans la liste nous trouverons notre Pololu A4988. Plaçons-le à côté de l’ATMEGA328, sa pin 8 faisant face à la pin 11 de l’ATMEGA328.

N’oubliez pas d’alimenter le Pololu avec +5V et GND.

Liaison des composants

Bien! Nous avons placé nos composants, il faut maintenant câbler le schéma.

Commençons par cliquer sur le segment vert dans la barre d’outils de droite (placer un fil).
Le fonctionnement est simple: clic 1 sur la pin 1, clic 2 sur la pin 2. Les clics intermédiaires permettent d’ajouter des coudes au fil.

On va relier comme ça la résistance à la pin 13, la résistance à la LED, et les alimentations.

Assignation de valeurs aux composants

En regardant le schéma, on se rend compte que la valeur de la résistance n’a pas été définie. Nous allons placer la souris au-dessus de la résistance, et appuyer sur E (Edition).
Une fenêtre s’ouvre et nous propose (entre autres) de donner une valeur au composant.

Si jamais un menu « Clarification sélection » s’affiche, sélectionner « Champ valeur » et indiquer 220.

Bilan

Et voilà, après avoir raccordé le pololu à l’ATMEGA328, vous devriez avoir un schéma similaire à celui-ci.

Allez, ça ira pour l’instant 🙂

Prochaine étape: le circuit imprimé!

Plaque décorative de la comté

Pâques arrive avec son lot de chocolats, retrouvailles de famille et d’amis, et annonce une inexorable tôle pour le vendredi soir!

A l’occasion de nos retrouvailles annuelles, l’ami Geo m’a demandé si je pouvais lui fabriquer une plaque « Bag End » pour mettre devant chez lui, en référence à la maison de Bilbon Sacquet du même nom.

Le petit challenge, c’est que les dimensions demandées ne me permettaient pas de fabriquer la pièce en une fois.
Alors j’ai fait un petit assemblage façon puzzle (j’vais lui montrer qui c’est Raoul!), histoire que les deux morceaux ne s’écartent pas trop avec le temps et l’humidité, et que ça ne devienne pas tout dégueulasse.

La pièce mesure 51x30cm.

Détail de la gravure

Raccord pas trop vilain

Le making of !

Chaque moitié a été usinée de la manière suivante:

  1. Contour à la fraise ronde pour la moulure (4mm de profondeur, fraise de 1/4 de pouce)
  2. Découpage à la fraise droite de 1/4 de pouce (passes de 3mm, avec des tenons pour éviter que ça se barre à l’étape 3)
  3. Gravure du texte à la fraise conique de 120°
Moulure gravée à la fraise ronde
Brut de décoffrage
Les deux parties après nettoyage. Évidemment il a fallu poncer un peu au niveau de l’assemblage pour que ça rentre…
Et paf! un peu de colle, deux serre-joints, et une bonne nuit de sommeil…

Et le résultat final

L’ami Geo s’est ensuite attelé à arranger le panneau pour le vieillir et lui donner un air authentique. Il a noirci l’intérieur des lettres, il y est même allé au chalumeau le cochon. Puis ponçage, vernis, ponçage, vernis (répéter jusqu’à ce que le pot soit vide). Il explique ça bien plus en détails ici.

Le résultat est vraiment mortel!

Ça a de la gueule!

Module SD universel pour Reprap: premier test grandeur nature !

Après une longue phase de debugging et d’incantations aux dieux de l’électronique, j’ai finalement osé tester mon petit montage sur l’imprimante 3D! (rappel des faits)

J’avais une boîte à imprimer pour madame, et j’ai profité de l’occasion pour essayer le bazar. Je ne vous cacherai pas qu’il y a eu quelques faux départs et réglages avant d’arriver à cette impression impeccable de 2h50 🙂

Le montage est connecté au port AUX1 de la carte RAMPS (connexion qu’on ne voit absolument pas sur cette photo…)

L’unique connexion se fait par 4 fils avec le port AUX1 du RAMPS. Ces 4 fils correspondent au +5V, 0V, Rx et Tx.

Donc ce module n’a pas besoin d’alimentation externe, ce qui est plutôt cool!

Et voilà une belle boîte pour ranger le mascara et autres poupouilles de salle de bain 🙂

Déclencheur pour réflex Canon à base d’Arduino

  • Bonjour Pierre, vous connaissez ma femme?

  • Oui, chef…

  • Elle est belle hein?

  • Oui, chef…

Et en plus d’être belle, elle a des envies lubies obsessions photographiques très précises, comme prendre des dominos en train de tomber, pour figer le mouvement.

Le truc, c’est que prendre ce genre de photos, c’est assez chaud, pour les raisons suivantes:

  1. Déclencher l’ouverture à la main avec précision est… très difficile,
  2. Pouvoir répéter une photo est… impossible,
  3. Les dominos se cassent la gueule pour un oui ou pour un non,
  4. Ma femme n’est pas patiente DU TOUT.

Pour ces raisons, je lui ai fabriqué un déclencheur automatique, à base de barrière infrarouge et d’Arduino.

Le principe

La barrière IR est constituée d’une pièce en U imprimée en 3D, dans laquelle sont insérées face à face une LED IR et une photodiode.

Le principe est simple: on cale notre premier domino au fond de la boîte, et en tombant il va couper le faisceau infrarouge. Coupure de faisceau qui déclenche l’appareil photo après un délai soigneusement choisi (ou disons que le terme « empiriquement » serait plus approprié).

L’électronique

C’est une Arduino Uno qui gère le capteur et le déclenchement.

Voici l’interface entre l’arduino et l’appareil photo:

connecteur jack arduino canon eos 500D
Figure 1: schéma extrêmement académique et normalisé de la connexion

 

Le résultat final

Le résultat final, avec le dernier domino en suspension…

Précisions sur les réglages de l’appareil

Les dominos tombent très vite. j’ai calculé, ça fait 20ms par domino. Selon mes savants calculs, l’extrémité supérieure du dernier domino se déplace à la vitesse infraluminique (le contraire vous aurait étonnés, hein) de 3.5m/s.

Alors si vous êtes comme ma femme et que vous voulez que le dernier domino soit parfaitement net, il va falloir adopter une vitesse méga rapide de 1/2000ème de seconde.

Autant dire qu’à cette vitesse, il vaut mieux éclairer fort (ici, c’était en extérieur), et on était à 400 ISO.

Copinage

Si vous êtes intéressés par un blog de photographe en plein apprentissage, assistée par un technicien aussi patient que la photographe est pointilleuse, allez faire un tour loin du tumulte!

Prototype de contrôleur à base de carte SD pour Teacup

Salut!

Comme je l’expliquais dans mon précédent article, je suis passé sur Teacup et mon contrôleur LCD/SD d’origine n’est pas compatible avec ce firmware. Et je n’ai pas du tout envie que mon imprimante 3D soit dépendante d’un PC pour pouvoir fonctionner.

Teacup gèrerait a priori la présence d’une carte SD, mais visiblement il  faut envoyer du G-Code pour lister les fichiers (via un PC, donc…), et l’ensemble n’est pas vraiment documenté. Même chose pour l’affichage.

Alors je me suis lancé dans la conception d’un contrôleur qui discutera avec le firmware de la machine, quel qu’il soit. Rien que ça, mon pote!

Idéalement, il disposera d’une interface web (ESP8266 powaaa!), mais pour le moment j’ai fait un proof of concept avec une Teensy 3.2, un afficheur OLED SSD1306 et un lecteur de carte microSD. Et le pire dans tout ça, c’est que ça a l’air de marcher!

Voici le montage en mode breadboard:

A gauche, l’écran, au milieu le lecteur microSD, à droite la Teensy, et en haut l’Arduino Mega 2560 (avec Teacup). Au dessus de tout ça, un sacré bordel de fils. A gauche, une résistance de 220Ω qui n’a rien à faire dans le montage, mais oh, je suis encore chez moi, non?!

La communication entre mon petit bazar et Teacup se fait par port série. Après l’envoi de chaque commande, le programme attend l’acknowledgement du firmware (un bête « ok ») avant d’envoyer la commande suivante.

Pour le moment, j’affiche juste la ligne courante sur l’écran, mais je vais faire évoluer ça pour afficher les températures et l’avancement de l’impression.

Changement forcé de firmware sur l’imprimante 3D

Une nouvelle année s’ouvre à nous, et je vous la souhaite bien bonne!

Pour démarrer en beauté, j’ai commencé par « casser » mon imprimante 3D. Bravo champion!

L’histoire a commencé (enfin c’est ce que je pense) alors que je regardais jusqu’où je pouvais pousser mon plateau Y, dans l’idée d’imprimer une pièce assez grande (une pièce de quadricoptère, mais j’aurai tout loisir de revenir là-dessus dans les mois à venir!)

Bref, suite à ça, je vais pour imprimer une petite pièce en PLA, et là, paf! le plateau ne chauffe pas. Je contrôle la résistance du plateau, 1Ω et quelques (correct), mais à la sortie du RAMPS, j’avais 2 pauvres volts qui se couraient après pour alimenter le plateau (normalement on est à 12…)

Visiblement un fusible ou un Mosfet a grillé à cause d’un court circuit que je suppose provoqué par ma poussée un peu extrême du plateau (oui, les connexions sont artisanales…)

Alors je ne me démonte pas de souci, je remplace le RAMPS par un deuxième que j’avais en stock. Je rebranche tout mon petit bazar, j’allume, et là… j’ai plus rien compris au fonctionnement des moteurs. X et Y nickel, par contre Z et extrudeur ne tournaient plus. Ou si. Ah, et puis finalement non.

J’ai flashé l’Arduino avec la dernière version de Marlin, pas mieux. Alors après analyse, un des Pololus avait grillé, mais même en le remplaçant, j’avais un fonctionnement totalement aléatoire des moteurs Z et E…

Au bout d’une journée et demie d’agacement intensif et d’une envie (heureusement réprimée) de sauter dessus à pieds joints, j’ai décidé d’installer un autre firmware déjà essayé dans le passé sur une autre machine: Teacup.

Hé ben tu l’crois, tu l’crois pas: tout est rentré dans l’ordre. Les 4 axes fonctionnent, les endstops aussi, le plateau chauffant et la buse aussi, il n’y a plus qu’à tout recalibrer (depuis l’écriture ce cet article, c’est fait et ça marche nickel).

Des fois faut pas trop chercher… En tout cas pour moi, Marlin, c’est fini. Non Marlin, ne dis rien, je ne t’écouterai pas! Mais il va quand même que je trouve un palliatif pour pouvoir imprimer depuis une carte SD parce que là, je dois me brancher en USB depuis le PC…

Interfaces de programmation pour ESP8266

La première question qu’on se pose quand on reçoit un ESP8266, c’est…

« Ah merde, mais comment je vais programmer ce machin? »

Il y a besoin de 4 fils : +, -, Rx et Tx, donc la première chose, c’est de se procurer un convertisseur USB-série. Le point crucial, c’est la tension de sortie de ce convertisseur. Elle doit être de 3.3v à la fois sur le Vcc ET sur le Tx. Le risque avec du 5V, c’est tout bêtement de griller l’ESP.

L'interface USB-série
L’interface USB-série. On peut voir en bas le sélecteur 5V-3.3V, et en haut le bouton reset.

L’ESP8266 01 a des broches au pas de 2.54mm, mais n’est pas utilisable dans une breadboard à cause de la position des broches. Donc soit on y va avec des fils et des connecteurs Dupont, soit un se fait un petit circuit imprimé pour connecter tout ça à l’adaptateur USB-série. Au début, j’utilisais la première méthode, mais j’ai finalement opté pour un petit circuit imprimé…

Vert jaune rouge... Rastaman!
Vert jaune rouge… Rastaman!

A gauche, il y a un emplacement pour un cavalier. Il sert à faire démarrer l’ESP8266 en mode programmation.

Oui, je n'avais que des connecteurs femelles à 8 contacts...
Oui, je n’avais que des connecteurs femelles à 8 contacts… C’est joli le scotch…
Et l'ensemble connecté sur le PC, prêt à être programmé!
Et l’ensemble connecté sur le PC, prêt à être programmé!

Le truc avec l’ESP8266, c’est qu’il se décline en je ne sais combien de versions différentes. J’ai aussi un 12e sous la main, et pour lui, l’emplacement des broches est un peu plus particulier, dans le sens où elles sont espacées de 2mm, et non de 2.54mm. Du coup j’ai dû commander des headers au pas de 2mm afin de faire un programmateur et adaptateur.

Il est juste glissé entre les headers pour faire le contact. Pas de soudures, c'est cool!
Il est juste glissé entre les headers pour faire le contact. Pas de soudures, c’est cool!

Après coup, je me dis que j’aurais pu placer les headers pour faire en sorte que l’ESP8266 soit carrément enfiché sur les headers. Mais là, ça va pile poil.

Il faut un cavalier en permanence entre la GPIO15 et la masse pour qu’il démarre (ça il faut le savoir…), et un autre en bas pour mettre la GPIO0 à la masse (ça c’est pour le mode programmation).

Côté connection au PC, c’est le même principe.

Un peu plus gros mais ça va bien :)
Un peu plus gros mais ça va bien 🙂

 

Mini tuto sur MakerCam

A la demande d’un lecteur (Nico, si tu nous entends…), je me suis penché sur makercam, un program de CAM en ligne (et en Flash) qui permet de générer des fichiers gcode à partir de dessins 2D réalisés directement sur le site, ou importés depuis un fichier SVG.

Note: j’ai fait ce test sous windows pour des raisons… de flash…

makercam vide
MakerCam à l’état naturel

Ok, donc nous allons, pour cette démo, réaliser la découpe de la lettre A.

Par pur souci de fainéantise, je vais dessiner un A de gros cochon à main levée directement dans makercam. Ne pas oublier de passer en centimètres en haut à droite si on veut travailler en centimètres!

makercam lettre A
Ah bah c’est du joli!

Avec l’outil flèche (en haut à gauche, le 2ème bouton), nous allons sélectionner notre A au complet. Il apparait en rouge.

Pour découper cette lettre, des opérations de contour (profile en anglais) suffisent. Disons que nous voulons faire une découpe sur 10mm de profondeur.

Allons ensemble, si vous le voulez bien, dans le menu CAM>Profile. Une boite de dialogue s’ouvre et nous pouvons entrer les paramètres de l’opération.

Disons que j’ai une fraise de 1/8 » (3.175mm)

Je rentre mes paramètres:

makercam profile
Création de l’opération de découpe

En cliquant sur OK, notre A se remplit de bleu. Il est temps de générer le parcours d’outil, en allant dans CAM>Calculate all!

makercam toolpath
Le parcours d’outil s’affiche en vert

Ok, donc là on est pas mal. Mais si on découpe ça tel quel à la machine, à la dernière passe, notre pièce risque de bouger et de prendre un coup de fraise dans les côtelettes. Pas top.

Nous devons donc éviter que la pièce soit totalement détachée, et pour ça nous allons mettre en place des tenons (tabs en anglais).

Avec notre forme toujours sélectionnée, allons dans CAM>add tabs to selected.

Un menu s’affiche, et on peut y définir l’espacement entre les tenons, ainsi que leur longueur et leur épaisseur.

Paramétrage des tenons
Paramétrage des tenons
makercam-tabs
Les tenons ont été générés, mais l’emplacement c’est pas toujours idéal

Il ne faut pas hésiter à les faire glisser à la souris pour qu’ils soient plus faciles à découper manuellement après l’usinage.

Une fois que tout est prêt, il n’y a plus qu’à recalculer les parcours d’outil (CAM>Calculate all), et on peut maintenant exporter le G-Code 🙂

CAM>Export GCode. On sélectionne tout, et on clique sur Export selected toolpaths. Il n’y a plus qu’à télécharger le fichier, qu’on peut éventuellement visualiser dans Chilipeppr:chilipeppr

Détail des tenons
Détail des tenons

Bon, j’avoue que je ne suis pas ultra fan de MakerCam, il y a quelques bugs et des comportements bizarres à l’utilisation; mais ça peut quand même bien dépanner si on n’a rien sous la main pour générer du G-Code.

En tout cas, c’est un énorme boulot qu’il faut saluer, et le programme est open source!

Fonctionnalités très appréciables dans l’IDE Arduino

Adieu l’équipe!

J’avais envie d’écrire un petit article pour saluer les évolutions de l’IDE Arduino.

Par rapports aux débuts, il y a eu à mes yeux deux avancées majeures: le gestionnaire de cartes et le gestionnaire de librairies.

Le gestionnaire de cartes

Aujourd’hui, l’IDE Arduino est utilisable avec de nombreux microcontrôleurs, par forcément Atmel.

Parmi les cartes notables que j’ai pu utiliser, il y a la Teensy 3.x et l’ESP8266.

Evidemment, le protocole d’upload des programmes vers l’un ou l’autre des microcontrôleurs est différent, et l’IDE doit savoir comment communiquer.

Pour cela, on a le menu Outils>Types de cartes, et on peut sélectionner la bonne. Mais quid des cartes non listées dans ce menu?

Et bien c’est pas compliqué.

Avant tout, il faut éventuellement ajouter la source du package pour obtenir le driver de cette carte, dans les préférences de l’IDE:

arduino-esp-preferences

Puis on va dans Outils>Types de cartes>Gestionnaire de cartes et nous avons à disposition une liste de cartes pour lesquelles on peut installer le driver, et paf! il n’y a plus qu’à la sélectionner dans le menu pour la programmer. Sympa! (bon, pas de pot, la Teensy n’apparait pas dans cette liste, il faut installer Teensyduino, un complément disponible sur le site du constructeur).
Donc plutôt pratique le gestionnaire de cartes.

arduino-esp-boards

Le gestionnaire de librairies

Alors là c’est encore mieux!
Tu as dégoté un nouveau composant et tu n’as pas le cœur à te farcir la datasheet pour comprendre comment discuter avec lui? Comme je te comprends…
Prenons à tout hasard le DHT22, qui est un capteur de température/humidité assez répandu.
Hé bien pas de prise de tête: on va dans Croquis>Inclure une bibliothèque>Gérer les bibliothèques. Une liste se charge, on tape DHT22 dans le filtre en haut, et paf! on tombe sur DHT sensor library by Adafruit.

arduino-dht22-librairy

Il n’y a plus qu’à cliquer sur le bouton installer, et on se trouve non seulement avec la librairie disponible, mais il y a aussi des exemples disponibles dans Fichier>Exemples! C’est-y pas beau, ça? Hein?

arduino-dht22-exemples

J’ai particulièrement apprécié cette fonctionnalité avec un capteur que j’avais acheté il y a quelque temps, et qui est une vraie merde à programmer: le MLX90614. C’est un thermomètre IR directionnel. Ça permet d’obtenir la température d’un objet sans contact. Mais alors pour communiquer avec, amuse toi si tu n’as que la datasheet sous la main… C’est un protocole I2C modifié, le truc bien relou.
Hé bien l’autre jour j’ai tapé MLX dans le champ de recherche du gestionnaire de librairies, et j’ai eu le plaisir de pouvoir utiliser le capteur hyper simplement. Merci à Adafruit d’avoir écrit cette classe…
Et d’ailleurs en regardant le code, c’est pas si long… Respect 🙂

Communiquer avec Adafruit IO en PHP

Salut tout le monde!

Voilà un moment que je n’ai rien posté, mais j’ai de bonnes raisons… Bricolage intensif sur l’ESP8266 (merci Sandrine de Bloguelinux) sur lequel je ferai très bientôt un gros billet 🙂

Bref, pour aujourd’hui, je vais vous parler de la plateforme Adafruit IO, qui est un superbe environnement pour stocker les données d’objets connectés.

La structure des données est simple et efficace: on crée des feeds, qui sont de simples listes de valeurs.

Chaque élément d’un feed a une valeur (une température par exemple), et éventuellement des coordonnées GPS.

Pour ma part, j’ai utilisé un capteur DHT22, et l’ESP8266 balance les données de température et d’humidité relative dans deux feeds.

Et avec les feeds, on peut (entre autres) afficher des courbes :

adafruit io graphique
Ça caille encore un peu dans le salon…

https://io.adafruit.com/toxnico

L’interaction avec AdaFruit IO pour envoyer ou lire les données se fait par une API REST; du coup je me suis dit qu’il serait intéressant d’avoir la possibilité, en PHP, de charger la dernière valeur de chaque feed pour l’afficher sur un site web par exemple.

Alors j’ai écrit cette petite librairie sous GPL v2 pour permettre à tout le monde de récupérer facilement ses données : https://github.com/toxnico/php-adafruitio

Vos retours et impressions sont les bienvenus!

A très bientôt pour une grosse aventure ESP8266 🙂