[Tuto FlatCAM] Fabrication d’un circuit imprimé: du fichier Gerber au fraisage

Voici l’article qui boucle la boucle, et que je voulais écrire depuis longtemps! Nous allons fabriquer le circuit imprimé dessiné sous KiCAD lors des dernières sessions.

Voici les étapes qui vont nous mener à un circuit opérationnel:

  1. Export du circuit au format Gerber (isolation, perçage et découpe)
  2. Importation des fichiers Gerber dans FlatCAM
  3. Traitement dans FlatCAM (miroir, manipulation de géométrie et export en G-Code)
  4. Ouverture des fichiers G-Code dans bCNC, mise à zéro, mise à niveau automatique.(Hum, désolé, ça c’est pour plus tard)
  5. Usinage

1. Export au format Gerber depuis KiCAD

Nous partirons de ce schéma:

Le format Gerber est le standard utilisé dans la production de circuits imprimés. Il contient la description des pistes, des textes, des perçages, et toutes les informations nécessaires à la fabrication du circuit.

Pour notre projet, nous allons exporter 3 fichier Gerber:

  • Contour des pistes
  • Perçages
  • Contour du circuit (pour la découpe)

Cliquons sur le bouton

Comme je disais, nous n’exporterons que les pistes de la couche de cuivre (rouge, F.Cu) et les découpes (jaune, Edge.Cuts).

En haut, choisissons le répertoire de sortie, relatif au projet KiCAD (ici, gerber/), et cliquons sur le bouton [Plot] en bas de la fenêtre. Normalement, KiCAD nous a généré deux fichiers d’extension gbr.

Il ne nous reste plus que le fichier de perçage. Cliquons sur le bouton [Generate Drill File].

On va choisir le format Gerber, et les millimètres comme unité. Attention, ne pas cocher [Mirror Y Axis] !

Une fois que tout est prêt, cliquer sur [Drill File]

KiCAD a généré un fichier .drl dans notre répertoire, et c’est tout ce qu’il nous manquait! Nous pouvons passer à l’étape suivante 🙂

2. Import des fichiers Gerber dans FlatCAM

Si vous ne connaissez pas encore FlatCAM, c’est le bon moment! C’est un programme très puissant, même s’il est parfois un peu buggé lorsqu’il s’agit de manipuler les géométries. Mais pas de panique, je vais vous expliquer.

FlatCAM, brut de décoffrage

Nous allons importer nos trois fichiers (deux gbr et un drl):

  • File>Open Gerber, et sélectionner les deux fichiers gbr.
  • File>Open Excellon, et sélectionner le fichier drl.

Et voici où nous en sommes:

Ok donc là, FlatCAM affiche nos fichiers Gerber. Nous allons maintenant les manipuler pour pouvoir générer du G-Code (oui, c’est le but, faut pas l’oublier)

La première chose à faire, c’est de tout retourner, car le circuit sera gravé par en-dessous. FlatCAM a une fonction pour ça, qui s’appelle mirror. Alors nous allons déjà renommer les 3 fichiers dans FlatCAM, et vous comprendrez pourquoi.

Double-cliquons sur le 1er fichier, et changeons son nom par quelque chose de plus court, comme cuivre par exemple. Pareil pour les deux autres (decoupe, percage).

Si j’ai voulu donner des noms plus courts aux fichiers gerber, c’est parce que nous allons devoir effectuer une symétrie (miroir selon l’axe Y). Bah oui, nous devons graver le circuit à l’envers…

Pour appliquer la symétrie à nos 3 fichiers, malheureusement, pas de solution « cliquer ici ». Nous allons utiliser la console de FlatCAM. Si elle n’est pas déjà visible en bas de l’écran, aller dans le menu Tool>Command Line.

Il y a une tapée de commandes disponibles (help pour avoir la liste).

Nous allons symétriser nos 3 fichiers gerber avec la commande suivante:

Ok, on a symétrisé nos objets, mais vous avez vu où ils sont maintenant?? On va repositionner tout ça aux alentours de (0,0) pour une question de… maniaquerie. Et de volonté de ne pas péter les outils au moment de l’usinage avec un retour à (0,0) aléatoire. Allez, +146 en X, et +108 en Y:

Il ne se passe rien? cliquons sur le bouton [Replot] de la barre d’outils, et FlatCAM va redessiner l’affichage. Je parlais de bugs, c’en est un.

2.1 Génération de G-Code pour la gravure d’isolation

Superbe! Nous n’avons maintenant plus qu’à générer le G-Code pour fabriquer notre circuit imprimé.

Double cliquons sur l’objet cuivre dans la liste de gauche.

Les détails s’affichent.

Je ne vais malheureusement pas tout détailler car je suis une grosse feignasse. Les blocs qui nous intéresseront sont essentiellement Isolation Routing et Board Cutout.

Dans notre cas précis, nous allons ignorer Board Cutout, car nous avons une découpe assez tarabiscotée pour ce circuit. Mais sachez que cette commande permet de générer un tracé de découpe rectangulaire autour du circuit. C’est souvent suffisant.

Nous devons définir le diamètre de notre outil (ici, c’est une pointe de 0.4mm), et le nombre de passes d’isolation (en général je laisse une seule passe).

Une fois ces paramètres définis, cliquons sur [Generate Geometry] (le premier bouton, en bas du bloc Isolation Routing. Vous allez voir les pistes s’entourer de lignes rouges, éloignées de 0.2mm (le rayon de notre outil).

Retournons dans l’onglet Project. FlatCAM a créé un nouvel objet, cuivre_iso. Dans la terminologie de FlatCAM, c’est un objet de type géométrie. Il contient les lignes rouges en question.

Vous voyez le panneau de détails? On se rapproche du G-Code 🙂

Il faut indiquer la profondeur de gravure (Cut Z), la hauteur lors des déplacements rapides (Travel Z), la vitesse d’avance pour la gravure (Feed rate), et le diamètre de l’outil (Tool Dia.) On clique sur [Generate], et hop! Apparaissent des lignes bleues, qui représentent les traces réelles de l’outil.

Retournons sur l’onglet Project, et ô surprise, FlatCAM nous a généré un objet de type cnc : cuivre_iso_cnc.

On arrive au bout!

S’il n’y a rien à ajouter au début ou à la fin du fichier G-Code, il n’y a plus qu’à cliquer sur [Export G-Code], en bas, et enregistrer le fichier où bon vous semble.

2.2 Génération de G-Code pour le perçage

Wouuuhou! Bon, d’accord ça a l’air un peu long comme ça, mais c’était décrit en profondeur.

Passons au perçage. Z’allez voir, c’est plus rapide. On va revenir sur l’onglet Projet, et double cliquer sur notre objet percage.

FlatCAM nous affiche la liste des différents diamètres de trous utilisés dans le circuit (0.8mm, 1.0mm et 1.32mm).

Si vous vous en foutez et que pour vous, un trou c’est un trou, avec une taille unique, laissez les 3 lignes sélectionnées. Sinon, si vous voulez distinguer les diamètres et changer d’outil entre chaque série de perçage, il faudra sélectionner successivement les 3 lignes, et générer 3 objets cnc.

Pour la démo, on ne va pas se casser la nénette (oui, je suis toujours aussi peu courageux), et générer un seul objet cnc. Donc laissons les 3 tailles d’outils sélectionnées. Ajustons la profondeur de perçage (Cut Z, la hauteur pour les déplacements rapides (Travel Z) et la vitesse d’avance verticale (Feed rate), puis cliquons sur [Generate].

J’ai spoilé, je suis désolé. FlatCAM a généré un nouvel objet cnc: percage_cnc.

Et c’est kiki va générer un G-Code pour le perçage?

2.3 Une découpe un poil compliquée – manipulation de géométrie

Alors bon, cette partie, c’est seulement si on veut une découpe un peu tordue, comme celle de mon exemple. Sinon, passez votre chemin.

Parmi les fichiers Gerber, il y en a un qui s’appelle decoupe. Sélectionnons-le.

Disons qu’on veut l’attaquer avec une fraise de 1.5mm. On va précéder exactement comme pour générer la géométrie de l’isolation des pistes, sauf que le diamètre de l’outil sera de 1.5mm

J’avais prévenu que ce serait la merde… FlatCAM génère deux lignes: une à l’extérieur, et une à l’intérieur. Nous devons nous débarrasser de cette dernière.

Il faut pour cela sélectionner l’objet Géométrie créé (dans notre cas, decoupe_iso), et passer en mode Edit Geometry avec le bouton . Les lignes rouges changent alors de couleur.

Le but de la manœuvre, c’est de dessiner un polygone entre les deux lignes rouges, et d’effectuer une union booléenne entre les 2 lignes rouges d’origine et ce polygone, pour ne conserver que l’extérieur. Oui, c’est un peu lourdingue, mais c’est la seule façon que j’ai trouvée pour arriver à mes fins. Si vous en avez une autre, je suis preneur!

Donc, une fois en édition de géométrie, cliquons sur le bouton . Il s’agit ensuite de dessiner notre polygone entre les deux lignes de contour. Pour terminer le polygone, taper [Espace].

Une fois le polygone terminé, cliquer sur le bouton pour rafraîchir la géométrie et quitter le mode édition. Mais pas de panique, on y retourne tout de suite.

Allez! Rebelote :

La manip qui va suivre est un peu délicate pour cause de petit bug de sélection. On va zoomer à mort dans un coin de notre circuit, et cliquer sur le polygone que nous avons tracé précédemment. Il doit devenir noir.

Ensuite, appuyer sur Ctrl et cliquer sur le contour restant. Le reste devient noir.

Cliquer ensuite sur le bouton Polygon Union :

Les deux lignes intérieures devient rouges.

Valider en cliquant sur .

Notre géométrie est maintenant correcte!

Encore une étape et nous pourrons sauter au point 2.1 pour la génération du G-Code… Il faut créer des petits points d’attache (tenons, ou tabs en anglais), sinon notre circuit va voler à la fin de la découpe.

L’article est long hein… Je suis éreinté. Je voulais enchaîner sur bCNC mais je le ferai dans un prochain article.

Allez, on y va pour les tenons, dedieu dedieu!

Pour créer des tenons, il faut modifier encore un peu la géométrie précédente, en coupant la ligne à deux endroits.

Nous allons de nouveau éditer la géométrie decoupe_iso, et dessiner deux rectangles de 5mm sur la ligne, un en haut et un en bas.

On va revalider en cliquant sur le bouton OK en haut, puis retourner en mode édition. Maintenant, on va sélectionner le tracé du contour, puis le rectangle avec Ctrl. Les deux sont noirs? Ok. Allons dans le menu Drawing>Cut Path. Boum. FlatCAM a coupé notre contour. Il n’y a plus qu’à sélectionner le rectangle et l’effacer (touche – du clavier). Et pareil pour le tenon du bas.

Il suffit maintenant de refaire le point 2.1, en ajustant le diamètre d’outil, la profondeur, et en cochant éventuellement la case Multi Depth pour faire plusieurs passes de découpe (dans ce cas, indiquer la profondeur de chaque passe juste en-dessous).

Ouf! On a enfin fini!

Nous avons donc maintenant nos trois fichiers G-Code (gravure, perçage et découpe), et il n’y a plus qu’à les envoyer dans la machine avec bCNC. Mais ça, c’est pour un prochain article, parce que là, cet article est déjà trèèèès long et je suis au bout de mes forces 😀

[Tuto KiCad] Concevoir un circuit imprimé partie 2: le circuit imprimé

Vous avez aimé le premier article sur KiCAD? vous n’avez plus rien mangé ni bu en attendant la suite? Hé bien faites-vous un gros sandwich avec une bonne bière, car la voici!

Alors avant de commencer, je souhaite me dédouaner d’une chose. Dans le premier tuto, je vous ai présenté les fonctions de base de KiCad en construisant un schéma sans queue ni tête. Dans cette seconde partie, nous n’utiliserons pas le schéma présenté précédemment, mais un vrai schéma pour un vrai projet. C’est plus concret, et surtout, je ne travaillerai pas pour rien, hé hé 🙂

Alors voilà, nous allons partir sur un petit circuit pas méchant. L’idée, c’est de faire un mini shield pour une Arduino Uno, qui va générer un signal sinusoïdal grâce à un DAC (MCP4921). Le DAC pilote un MOSFET pour alimenter une LED de puissance.

Voici le schéma KiCad :

Assigner des empreintes aux composants

Le schéma reste un schéma, et ne reflète pas forcément la réalité physique des composants. D’ailleurs, un même composant peut se présenter sous différentes formes. Typiquement, il peut y avoir une version montée en surface (SMD, ou CMS en français) et une version traversante.

Et malheureusement, KiCad ne peut pas savoir quelle version de chaque composant nous voulons implanter sur notre circuit.

Par conséquent, à chaque composant, nous allons devoir associer une empreinte (c’est à dire une forme physique du composant). Et ce sont ces empreinte que nous allons par la suite positionner sur notre circuit imprimé.

Pour associer une empreinte à un composant du schéma, placez la souris au dessus du composant (ici le MOSFET) et appuyez sur F (comme Footprint).

En appuyant sur le bouton [Sélection], une fenêtre s’ouvre, et nous affiche une méga liste vraiment mal foutue, parce qu’on ne peut pas faire de recherche dedans. Il faut savoir ce qu’on veut. A gauche, on a les grandes familles de composants (résistances, transistors, connecteurs…), éventuellement sous-catégorisés en SMD (Surface Mount Device) et THT (Through Hole Technology). En cliquant sur une famille, on a à droite sa liste d’empreintes de composants.

Dans notre cas, nous allons implanter un MOSFET au format TO-220. Je ne croyais pas dire des choses pareilles en public un jour, mais je réalise que parler de boîtiers TO-220, ça doit quand même faire une sacrée impression dans les dîners mondains.

Pour le DAC, c’est un Housings_DIP:DIP-8_W7.62mm.

Et pour les connecteurs, j’ai pris des Connect:AK300-2 pour les gros (entraxe de 5mm) Pin_Headers:Pin_Header_Straight_1x02_Pitch2.54mm pour les petits.

Ok, donc tous nos composants sont maintenant associés à une empreinte, alors passons à la suite!

Ah il faudra quand même que je vous montre comment créer une empreinte de composant, si jamais vous avez besoin de quelque chose qui n’existe pas dans la librairie standard. C’est important de savoir faire, et vous verrez c’est vraiment facile. Je ferai une aparté à la fin de l’article à ce sujet.

Donc!

Sur la barre d’outils de KiCad, en haut, il y a un bouton [NET]. Cette fonction va nous permettre de générer la netlist, qui est en fait un fichier texte récapitulant toutes les connexions entre les composants. C’est le maillage de notre circuit.

Cliquez sur [Générer], et KiCad va nous proposer d’enregistrer un fichier nom_du_projet.net dans le répertoire du projet. Parfait. Une fenêtre devrait apparaitre.

En fait, KiCad nous explique que chaque composant doit être annoté (par exemple, les résistances doivent être nommées R1, R2, R3…). Alors là, en général je m’en contrefous et je clique sur [Numérotation]. Je fais en général de petits circuits et je sais ce que je vais mettre dessus, et où.

Hop! Notre fichier .net est créé et nous allons pouvoir passer à la vue de conception de circuit imprimé. Pour cela, cliquer sur . Ce bouton est à droite de la barre d’outils.

La fenêtre PcbNew d’ouvre, avec un fond noir, encadré de rouge. Vide. Ah. T’inquiète, c’est normal. Nous allons importer notre netlist, et tout va se charger correctement: clic sur le bouton [NET] dans la barre d’outils, puis [Read Current Netlist]. L’opération peut prendre quelques secondes, et une fois terminée, nous pouvons fermer cette fenêtre.

Positionner les composants

Tout est bien là, mais VRAIMENT en vrac. On va réarranger un peu tout ce bazar avec les touche M et R (déplacer et pivoter, comme lors de la conception du schéma).

On y voit un peu plus clair!

Comme il s’agit d’un shield pour une Arduino Uno, il va falloir être précis au niveau des 4 connecteurs du haut et des deux du bas. L’espacement vertical doit être de 1.9 pouce.

Soit on la joue naïve (en regardant les coordonnées en bas), soit on utilise la grille comme il faut pour un placement efficace. Allez, je choisis pour vous: réponse 2.

La grille est un outil super puissant, pour peu qu’on sache l’exploiter. Nous allons définir une grille personnalisée, avec comme pas vertical 1.9 pouce, et comme pas horizontal 0.1 pouce (2.54mm) (on s’occupera de l’horizontal juste après).

Dans le menu Dimensions>Grid, entrons les deux pas (attention, selon votre configuration régionale, il faut peut être utiliser une virgule à la place du point. J’ai ce problème).

Une fois la grille validée, cliquons sur le bouton tout en bas de la barre d’outils de droite:

Il va nous permettre fixer l’origine de la grille. Nous allons poser cette origine sur la pin SCK du connecteur du haut. C’est la pin 13 de notre Arduino.

Ensuite, activons notre grille personnalisée avec clic droit>Grid select>User Grid.

On peut voir que la partie basse descend un peu trop bas… On va déplacer notre connecteur du bas pour qu’il soit placé sur la ligne de la grille, puis rétablir une grille au pas de 2.54mm pour réarranger vite fait les autres composants.

Procédons de la même manière pour placer notre connecteur du bas correctement en X, et réarrangeons le tout.

Nous pouvons maintenant créer les pistes de cuivre qui relieront nos composants, avec le bouton .

Peu à peu, nous arrivons à quelque chose comme ça:

Zone de remplissage

Nous allons relier toutes les masses à l’aire d’une zone de remplissage. Pour cela, cliquons sur le bouton , puis quelque part sur notre schéma. On choisit la couche de cuivre, le Net (dans ce cas, GND), puis OK. Nous pouvons ensuite dessiner un chouette rectangle autour de notre circuit (double clic pour le valider).

On peut afficher ou pas les zones de remplissage avec les boutons suivants:

Et pour reconstruire la zone, c’est la touche B du clavier.

Oh yeah! Mais le contour… C’est un peu trop conventionnel, non?

Pour terminer, nous allons donner une forme un peu exotique à notre circuit final.

Sélectionnons la couche Edge.Cuts à droite (elle est jaune normalement).

A l’aide des boutons et , nous allons nous éclater à dessiner un contour totalement déliraaaant (avec la voix de Stéphane Bern), puis re-appuyer sur B pour que KiCAD recalcule le remplissage de masse, et hooooop!

Supplément gratuit spécial été : créer une empreinte de composant personnalisée

Savoir créer des composants custom, c’est capital. Pouvoir le faire hyper facilement, c’est encore mieux. C’est d’ailleurs la raison principale qui m’a fait quitter Fritzing pour KiCAD. Avec Fritzing, pour créer un composant, c’est une putain de plaie. Ouverte. Et pas désinfectée. KiCAD, lui, a soigné cette plaie sans douleur ni cicatrice, et m’a même fait un gros bisou sur le front pour que j’oublie tout 🙂

Pour la démo, je vais créer un circuit intégré, le CD4011 (quatre portes NAND). Il a une valeur sentimentale, c’est le premier circuit intégré que j’ai eu l’occasion d’utiliser (Kosmos Electronic 2000… Souvenirs…)

Bref! Voici la tronche du circuit dans KiCAD, vite fait:

CD4011 à la Nico

Bien, maintenant nous allons créer l’empreinte de ce circuit.

Dans l’éditeur de schéma, cliquons sur le bouton Footprint Editor, puis sur New Footprint. On va l’appeler CD4011-DIP.

On va cliquer à droite sur Add Pads, et poser les 14 pastilles de notre circuit intégré (espacées de 2.54mm, et la largeur du circuit est de 7.62mm.

Avant de poser la 2ème pastille, on peut éditer la 1ère (touche E), et régler par exemple la forme et le diamètre de la pastille. Ce réglage sera repris sur les suivantes.

On va créer un répertoire cd4011.pretty dans le dossier du projet, puis aller dans Préférences>Footprint Libraries Manager, cliquer sur l’onglet Project Specific Libraries, et ajouter notre librairie d’empreinte comme ceci:

Après ça, File>Save Footprint in active Library, et on lui donne un nom (CD4011-DIP).

Et voilà! Les numéros de pins de l’empreinte collent avec celles du composant dans le schéma, et c’est toute ce dont on a besoin!

Il ne nous reste plus qu’à dire à KiCAD « Hey, j’ai créé une nouvelle bibliothèque d’empreintes, et j’aimerais l’utiliser dans mon projet. Je peux te montrer où elle se trouve? »

Depuis l’éditeur d’empreintes, on va donc dans Préférences>Assistant des librairies d’empreintes, et on parcourt notre disque dur jusqu’à l’emplacement de notre répertoire pretty. Il nous propose d’importer l’empreinte de façon globale, ou bien juste pour le projet actuel. Pour la démo, choisissons le projet actuel.

De retour dans l’éditeur de schéma, plaçons la souris sur notre composant, appuyons sur F, suis Sélection. On déroule la liste, et voici le graal: notre empreinte du CD4011 est présente et utilisable!

Bilan des courses

Si vous en êtes à lire ce paragraphe, félicitations!

J’avoue que l’article est assez long, j’ai essayé de l’illustrer le plus possible pour expliquer la démarche pas à pas… Normalement, entre le premier article et celui-ci, KiCAD devrait sembler plus accessible qu’au premier abord.

En fait, les raccourcis clavier sont capitaux dans KiCAD, et notamment:

  • M (move) : déplacer un élément
  • G (grab) : déplacer un élément en conservant ses connexions
  • E (edit) : modifier les propriétés d’un élément
  • F (footprint) : assigner une empreinte physique à un composant de schéma
  • Suppr (Delete pour nos amis suisses) : effacer un élément

Si KiCAD a un doute quant à l’élément qui se trouve sous la souris, il affichera un menu Clarification qui nous permet d’indiquer avec précision l’élément sur lequel on veut agir.

Avec tout ça, nous avons un beau circuit imprimé virtuel, il ne reste plus qu’à le fabriquer! Mais ce sera l’objet d’un prochain article 😀

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:

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.

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 🙂

 

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 🙂

Piloter Grbl par le port série

Hey, j’ai une bonne nouvelle : ma Shapeoko arrive à fonctionner, et surtout ne plus planter, et ce avec ma carte maison! Wouhouuu c’teu fête!

J’ai bagarré pour en arriver là. J’attends la carte « nouvelle mouture » du fabricant, mais impatient que je suis, je n’ai pas pu résister à la tentation de la faire fonctionner moi-même…:)

Le point sensible, d’après les forums et mes constats, c’est la liaison USB entre le PC et l’Arduino sur laquelle tourne Grbl. Alors je me suis dit que je pourrais utiliser une autre Arduino entre les deux, qui communique par liaison série.

J’aurai donc:

PC<– liaison USB –> Arduino 1 (relais) <– Liaison série (Rx/Tx) –> Arduino 2 (Grbl)

L’Arduino 1 est une Arduino Mega 2560, largement surdimensionnée mais j’en avais une en stock alors ça m’allait bien 🙂

Entre les deux Arduini (pluriel d’Arduino?), on a juste besoin de 3 fils: Rx Arduino 1 vers Tx Arduino2, Tx Arduino 1 vers Rx Arduino 2, et relier les masses entre elles (Gnd).

En fin de compte, sur l’Arduino « relais », j’avais besoin d’un port usb en entrée et un port série en sortie (la Mega 2560 en a 3, en plus du port zéro qui correspond à l’entrée USB). Quoique, ça devrait aussi fonctionner avec la librairie SoftwareSerial pour émuler un port série.

Bref, le programme est très simple et assure une communication bidirectionnelle: il lit ce qui entre sur le port 0 (le port USB) et l’écrit sur le port 1 (connecté à l’Arduino 2), et il lit ce qui arrive du port 1 pour l’écrire sur le port 0 (connecté au PC).

Le câble USB utilisé mesure 20cm (beaucoup plus court que le câble d’origine, et donc moins sensible aux interférences électromagnétiques). J’ai dû virer l’isolateur galvanique qui posait des problèmes de communication.

Et ça ne plante plus, mon pote. Ca ne plante plus! Enfin jusqu’à preuve du contraire hein, parce que je commence à avoir l’habitude des phases maniaco-dépressives avec cette machine…

L’intérêt de conserver une liaison USB est de pouvoir utiliser bCNC et les autres outils de contrôle pour Grbl. Si j’utilisais une carte SD, je serais limité dans les interactions avec la machine, et je ne pourrais pas bénéficier (entre autres) de l’autoleveling de bCNC.

Shapeoko 3, déconnexions USB et carte de contrôle

Je me bats avec ma Shapeoko 3 depuis à peu près le début, car il y a des déconnexions USB très fréquentes quand on attaque assez fort dans la matière. Par contre ce n’est pas le cas si on n’attaque pas trop fort dans la matière.

Un tour dans les forums et des discussion avec Jorge Sanchez (de chez Carbide 3D) m’ont laissé entendre que ces déconnexions étaient très probablement causées par des interférences électromagnétiques entre les moteurs (pas à pas, ou peut-être la broche) et le câble USB.

J’ai suivi les instructions de Jorge: raccordement de masses, utilisation d’un isolateur galvanique USB, mise à la terre. J’ai cru que c’était réglé, et puis c’est revenu… Ça m’a vraiment saoulé, et j’ai décidé de fabriquer ma propre carte de contrôle pour la machine.

Je suis parti sur des drivers pas à pas Pololu DRV8825, commandés par une Arduino Uno sous Grbl. Rien de très compliqué a priori, puisque j’ai déjà fait quelque chose de comparable avec mon CoreXY, sur 2 axes seulement.

Alors je me suis lancé, et j’ai fabriqué un circuit imprimé avec la Shapeoko elle-même (comme je disais, quand on grave et que ça ne force pas, ça marche!).

Côté design, j’ai utilisé Fritzing et Visolate.

Pour l’envoi sur la machine, j’ai découvert bCNC et croyez-moi c’est VRAIMENT le top. Je ferai certainement un article dessus pour la prise en main. Pour la faire courte, c’est un logiciel qui envoie le G-Code à la machine, mais qui permet de compenser l’axe Z selon les mesures faites au préalable avec un palpeur. C’est trop bien, particulièrement quand on grave un circuit imprimé et qu’on veut avoir une profondeur identique partout!

Bref, voici la fabrication de la carte en images.

Gravure PCB
Gravure des traces. Si si, ça tourne! C’est l’appareil photo qui est trop rapide 🙂

 

perçage pcb
Le perçage avec une mèche de 1mm.

 

bCNC
bCNC en pleine action! On peut voir le quadrillage effectué par le palpeur, avec les différences de hauteur.

 

Le circuit terminé
Le circuit terminé. C’est autre chose que ce que j’avais fait dans le passé!

 

Test pcb
Test avec 3 moteurs Nema17, concluant 🙂

 

J’ai branché les moteurs de la Shapeoko (Nema23) sur la carte, et.. Rien. Enfin si: des réactions, mais des réactions étranges.

En fait j’ai réalisé que les fils n’étaient pas agencés pareil au niveau des connecteurs!

Cablage moteurs pas à pas 4 fils
Codes couleurs des moteurs bipolaires à 4 fils. (honteusement piqué sur http://www.linengineering.com)

 

Avec les fils dans le bon ordre, le fonctionnement est bien meilleur, n’est-ce pas 🙂

Tout content, je lance un job avec des passes de 2.5mm dans du pin. J’y crois, j’y crois, j’y crois. Jusqu’à ce que ça se plante. La même. Exactement la même qu’avec le contrôleur d’origine de la Shapeoko. Autant dire que ma tête a pris successivement toutes les couleurs de l’image ci-dessus.

J’ai tout fait, j’ai essayé sur un PC de bureau (relié à la terre) plutôt qu’un portable, j’ai essayé à tout hasard un autre firmware, rien à faire. C’est relou hein…

Alors hier soir j’ai retenté le contrôleur d’origine, en diminuant la profondeur des passes (1.25mm) et ça va. Pour le moment en tout cas…

Mais c’est frustrant, quand on a une grosse machine, puissante, de devoir se coltiner des passes aussi fines, franchement…

[Edit du soir même] Hééééé ben non. Finalement ce soir elle ne voulait plus. Je commence à en avoir plein mon ass, mais alors vraiment…

[Edit du lendemain] Carbide 3D va m’envoyer une nouvelle carte (une nouvelle mouture, pas juste un remplacement de celle-ci). Même si je râle, j’apprécie énormément leur support, ils ne laissent pas leurs clients dans le mouise. C’est très important.

Si vous avez le même problème que moi, faites-moi signe, que vous l’ayez résolu ou non, ça m’intéresse!

Présentation du microcontrôleur Teensy

Mon Arduino Uno étant dorénavant dédiée à la graveuse laser CoreXY, j’ai cherché un autre microcontrôleur pour bricoler. Notamment pour piloter Ableton Live en MIDI.

Arduino Leonardo m’intéressait pas mal, car elle a la capacité de se faire passer pour un clavier, une souris, ou un périphérique HID quelconque.

Pendant mes recherches, je suis aussi tombé sur la Teensy 3.1. Certes, cette carte n’est pas open hardware, MAIS :

  • Prix similaire à la Leonardo (20$)
  • 256Ko de mémoire flash (32Ko sur la Leonardo)
  • 64Ko de RAM (2.5Ko sur la Leonardo)
  • 72MHz (16MHz sur Leonardo)
  • Des entrées capacitives (« touch »)
  • Une sortie analogique (pas PWM, j’ai bien dit analogique)
  • Une taille ridicule (CMB)
  • Support natif du MIDI par le port USB, sans avoir à installer de driver!
  • Et j’en passe.

Voici une cartographie de la bête:

https://www.pjrc.com/teensy/teensy31.html
Vue de dessus
Source : https://www.pjrc.com/teensy/teensy31.html
https://www.pjrc.com/teensy/teensy31.html
Vue de dessous

Pour la programmer, ça se passe avec une Arduino. On utilise un câble micro USB-B, et le même IDE. Il faut juste installer l’add-on Teensyduino pour pouvoir gérer cette carte.

Donc, avec tous ces avantages, j’ai craqué direct.

Comme je disais plus haut, cette carte a la possibilité d’envoyer des commandes MIDI par l’USB très simplement. Par exemple:

[code]

usbMIDI.sendNoteOn(note, velocity, channel) usbMIDI.sendNoteOff(note, velocity, channel) usbMIDI.sendControlChange(control, value, channel)

[/code]

Pour la liste complète des capacités MIDI de la Teensy, la doc est ici.

Pour une liste des numéros de notes MIDI, c’est par .

Bref, elle a tout ce dont j’ai besoin pour fabriquer un petit pédalier MIDI, qui me servira à sampler des boucles de basse en live!