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 🙂

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 🙂

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!

Fabrication d’un circuit imprimé à l’ancienne

J’aime bien me moquer proverbes, parce qu’ils permettent de tout justifier pour pas cher.

Le proverbe du jour autorise celui qui l’emploie à effectuer un virage à 180° sans souci : « il n’y a que les imbéciles qui ne changent pas d’avis »…

En effet, j’ai finalement investi dans le nécessaire pour graver chimiquement mes circuits imprimés. A l’ancienne. Comme dans les cours de techno du collège (pour les vieux comme moi qui faisaient des TP de techno).

Putain de fraiseuse! Dans l’article précédent, je vantais les mérites des zones de Voronoï, et je les vante toujours. Mais quand c’est trop serré, c’est trop serré. Impossible de graver un circuit imprimé un peu dense à cause du jeu. Et quand je dis « dense », je parle juste d’espacements de 2.54mm…

Enfin bref, ça m’a saoulé, et j’ai finalement pris la décision de passer au chimique.

J’ai commencé par tenter la fameuse technique du transfert de toner au fer à repasser sur la plaque de cuivre, avant de tremper le tout dans un mélange acide qui bouffera le cuivre non protégé par le toner.

La phase du transfert… Une horreur. Après pas mal d’essais, plusieurs types de papier, plusieurs durées de chauffe, des trempages interminables dans l’eau… Impossible d’avoir un tracé propre sur la plaque. D’la merde… Pour moi en tout cas. C’est dommage, parce que beaucoup y arrivent, mais perso ça m’a pris la tête. Alors j’ai pris mon portefeuille à deux mains et j’ai commandé :

  • une insoleuse en kit
  • une graveuse (bac chauffant qui fait des bulles)
  • des plaques photosensibles
  • du gros perchlorure de fer qui tache

Et là, même si le circuit n’est pas vraiment complexe, on peut quand même parler de propreté et de précision:

PCBpédalier midi

N’est-ce pas! ça, c’est un pédalier midi que je vais essayer ce soir avec les copains, et qui va me servir à sampler des boucles de basse sans toucher à l’ordi. C’est beau, non?

Produire un circuit imprimé avec des zones de Voronoï

Je voulais faire un circuit imprimé pour le CoreXY, pour pouvoir ranger mon petit bazar dans un boitier propre et libérer ma plaque d’essais.

Le truc, c’est que ma fraiseuse CNC souffre d’imprécision… Et comme je dois tracer des pistes et pastilles pour les Pololu (connecteurs espacés de 2.54mm), j’ai un peu peur du résultat…

Et je n’ai toujours pas envie d’utiliser des produits chimiques.

Alors j’ai investigué et j’ai trouvé une technique redoutable de production de PCB, qui devrait être capable de compenser l’imprécision de la machine : les diagrammes de Voronoï.

L’idée est, plutôt que de tracer les contours précis de chaque piste et pastille, d’aller « au plus large », et isoler uniquement les zones nécessaires. Un dessin vaut mieux qu’une longue histoire:

voronoi pcb
Le circuit à graver

Les lignes fines qu’on voit entre les pistes sont celles qui vont être fraisées. Après tout, on n’a pas besoin de faire le tour de toutes les pistes avec précision pour les isoler les unes des autres.

1. Conception du circuit

J’ai tout d’abord conçu mon petit montage avec Fritzing.fritzingJ’y ai mis mes deux pololu, des connecteurs pour les moteurs, les alimentations et le signal.

On bascule en mode « circuit imprimé », simple couche. Avec l’autoroutage (ou pas… mon circuit était autorouté d’une façon très bizarre), on met en place les pistes de cuivre.

fritzing-pcb
Je n’ai pas pu éviter un jumper…

2. Export au format Gerber

Depuis le menu fichier>exporter pour la production>gerber étendu, nous pouvons exporter le circuit imprimé au format Gerber. On obtient un répertoire avec une tapée de fichiers, dont deux nous intéressent particulièrement : pcb_corexy_copperBottom.gbl et pcb_corexy_drill.txt.

Le premier contient les traces du circuit imprimé, et le second les coordonnées des trous à percer (en pouces… sympa les gars).

3. Traitement du fichier Gerber avec Visolate

Traumflug, un membre très actif de la communauté Reprap et coauteur de Teacup, a écrit un programme en java qui permet de générer des zones de Voronoi à partir d’un fichier Gerber.

Après avoir téléchargé Visolate, ouvrons notre fichier gbl.

visolate-1

Les pistes et les pastilles apparaissent, avec des couleurs j’te dis même pas. Bariolées. Chaque couleur correspondra à une zone de Voronoi. La première étape est donc de réunir ce qui doit être réuni, avec le bouton « fix topology ». Avant de cliquer, il faut zoomer un peu avec le slider « dpi ». Le programme va scanner le circuit et réunir les zones de notre circuit imprimé.

visolate-2Cool! Maintenant, cliquons sur « make toolpaths »: Visolate génère les parcours d’outil pour fraiser les zones de Voronoi. Il n’y a plus qu’à enregistrer le fichier avec « save G-Code » et on est paré. Enfin presque.

visolate-3

4. Génération du G-Code de perçage

Comme je le disais au-dessus, Fritzing génère les coordonnées des perçages en pouces. Il faut faire la conversion en mm. Ou basculer la machine en mode pouces. J’ai opté pour la conversion en mm.

Le fichier des perçages a cette allure:

[code]

; NON-PLATED HOLES START AT T1
; THROUGH (PLATED) HOLES START AT T100
M48
INCH
T100C0.038000
T101C0.041667
T102C0.035000
%
T100
X015681Y004991
X017681Y012991
X015681Y014991
X017681Y009991
X015681Y005991
X017681Y013991
X015681Y015991

etc.

[/code]

J’ai fait un programme qui convertit cette suite de coordonnées en G-Code, et en millimètres s’il vous plait : GerberDrill.

Désolé pour l’interface utilisateur toute pourrie… Le principe est simple: parcourir pour aller chercher le fichier drill.txt, définir le code à générer pour chaque trou et cliquer sur « Process drill file ». Le programme génère du G-Code pour se rendre à l’emplacement du trou, et percer à la profondeur indiquée.

5. Concaténation des deux fichiers G-Code et miroir

Je voulais tout faire d’une traite, c’est à dire fraiser les zones de Voronoi et marquer les points de perçage (puis percer à la main avec une mèche de 1mm avec la Dremel).

Donc dans un fichier texte, j’ai mis à la suite le G-Code généré par Visolate et celui généré par mon programme GerberDrill.

Etape importante : il faut mettre un effet miroir sur le G-Code, car la gravure va se faire sur la face inférieur du circuit. Pour cela, dans le fichier G-Code, remplacer tous les « X » par « X-« .

On enregistre le fichier et zou! balance la purée papa!

Le jeu de ma machine se remarque particulièrement au niveau des points de perçage, lorsqu’ils sont près d’une trace. J’ai dû les arranger à la cochon en en élargissant quelques uns… Hélas je n’ai pas pris de photo de la plaque juste après la gravure, mais voici la vue de dessous une fois les éléments soudés:

Désolé pour les soudures dégueulasses...
Désolé pour les soudures dégueulasses…

La prochaine fois je pense que je marquerai les perçages avant de faire les isolations. En tout cas j’ai bien contrôlé au multimètre et ça a l’air bon.

PCB CoreXY
Les connecteurs soudés
PCB CoreXY avec drivers
Les pololu montés

On peut voir à gauche les connecteurs pour les signaux step et direction. A droite les deux connecteurs de moteurs, et les deux connecteurs d’alimentation (5V en haut pour la logique, et 12V en bas pour les moteurs).

Il n’y a plus qu’à connecter la carte, mettre le jus et en avant!

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!

Paramétrage de Teacup pour la gravure au laser

Pour envoyer mes impulsions PWM au module laser, j’utilise la commande M106 Px Sy de Teacup.

J’ai défini ma broche de commande du laser en tant que ventilateur dans Teacup, et cette broche envoie un signal PWM.

La section « heaters » dans ma configuration se présente comme ceci :

[code]

//DEFINE_HEATER(extruder, PD3,   0)
//DEFINE_HEATER(bed,      PB4,   0)
DEFINE_HEATER(fan,        PB3, 1)
// DEFINE_HEATER(chamber,  PIND7, 1)
// DEFINE_HEATER(motor,    PIND6, 1)

[/code]

J’ai désactivé l’extrudeur et le lit chauffant, inutiles pour ce que je fais. La broche PB3 correspond à la broche 11 de l’arduino uno.

Revenons à notre commande M106 Px Sy, qui prend deux paramètres:

  • P : l’index de la sortie dans la section « heaters », pour moi c’est 0 (je n’ai qu’une sortie heater)
  • S : la puissance du signal PWM, de 0 à 255

Lors des premiers tests avec une simple LED, j’ai réalisé que les commandes M106 n’étaient pas synchronisées avec les mouvements. En fait elles ne sont pas mises dans le buffer de commandes, mais directement exécutées. Alors Pour remédier à ça, il faut ajouter dans notre fichier de config :

[code]

#define ENFORCE_ORDER

[/code]

Autre souci que j’ai eu: la commande M106 faisait planter Repetier-host (il arrêtait spontanément d’envoyer les commandes).

Je suis passé sur Pronterface, et là, plus de problème! Des fois, faut pas chercher…

Première gravure au laser avec le CoreXY

D’abord, les faits :

Jack Daniels gravé au laser
100x67mm

 

Alors je vous vois venir : « Ouiiii m’enfin dis donc, ton étiquette de Jack, elle serait pas à l’envers des fois? »

La réponse est oui…

J’ai écrit un programme qui transforme une image bitmap en instructions G-Code de mouvement et de shoot au laser. Et comme les coordonnées Y sont inversées entre une image numérique (du haut vers le bas) et la machine, ben ça a retourné l’image.

Mais à vrai dire, ce n’est pas le sujet 🙂

Ce que je vois, c’est que la machine a shooté plus de 10’000 points en une trentaine de minutes, et ça, ça fait plaisir!

Voici l’image en haute résolution (cliquez avec la molette de la souris pour l’ouvrir, sinon elle s’ouvre en mode galerie… Je ne sais pas comment le désactiver :). C’est intéressant de voir que les points du laser son en fait des traits, et on y voit aussi la variation de puissance sur les bords des lettres.

La résolution est de 2 points par mm, soit 50 dpi.

On voit quelques lignes qui ont un léger décalage, mais je suis plutôt content du résultat.

jack
L’image d’origine : 135×200 pixels

 

Si vous êtes curieux, voici le G-Code généré par le programme à partir de l’image ci-dessus.

A part ça, j’ai arrangé un peu mes points d’attache de ficelle sur le chariot. C’est maintenant parallèle aux barres, ça va mieux!

Chariot CoreXY Chariot CoreXY