CNC: GRBL sur ESP32 serait l'arme absolue pour piloter des machines à commande numérique?

GRBL Encore???

Cet article clot une série visant à faire un petit tour d'horizon des solutions de pilotage de machine à commande numérique en 32 bits. Après Marlin 2 sur LPC, GRBL sur STM32, c'est au tour de GRBL sur ESP32. C'est promis après j'arrête. Ou pas :)...

ESP32? C'est quoi?

L'ESP32 est un SOC (System on Chip) embarquant 2 processeurs Tensilica Xtensa LX6 fonctionnant jusqu'à 160 Mhz. L'un est dédié aux télécommunications (Wifi), l'autre à l'utilisateur, bien que l'on puisse tout à fait utiliser les 2 cœurs dans une application.

Le LX6 est en fait un SIP (Semiconductor Interllectual Property core), c'est à dire le "code source silicium" permettant de fabriquer un processeur. Il est commercialisé sous licence par Cadence. Tout comme l'ESP8266 (son prédécesseur et petit frère monocœur), Il repose sur une architecture Harvard ( https://fr.wikipedia.org/wiki/Architecture_Harvard ).

Les 2 processeurs peuvent chacun accéder à la mémoire et au périphériques sur un bus partagé. La plupart des périphériques ont eux même un accès direct à la mémoire par DMA (Direct memory Access) ce qui en fait une architecture très performante.

Avec une fréquence de 160Mhz (240 sur certains produits), du Wifi et du Bluetooth 4LE intégré, cela fait une solution idéale pour motoriser bon nombre de projets DIY et même pro. Une récente annonce de recrutement sur LinkedIn de la société Awox, également propriétaire de Cabasse montre que leur enceintes connectées et produits intelligents ne vont pas tarder à se mettre à l'ESP32 :)..

Choisir un module ESP32

Pour en simplifier l'usage, il existe des modules de développement intégrant le processeur, une mémoire e2prom, un port USB avec convertisseur USB/série permettant la programmation et l'alimentation du module, l'antenne Wifi et des connecteurs d'entrées sorties. L'esp32s en est un exemple:

Ces modules ont considérablement évolués ces derniers mois, et il devient difficile de s'y retrouver. Si vous êtes perfectionniste, vous pouvez défricher les caractéristiques de ces nouveaux modules dans cet excellent article de ProjetsDIY.fr: https://projetsdiy.fr/quelle-carte-esp32-choisir-developper-projets-diy-objets-connectes/

Néanmoins pas de panique, le module de base à 5 euros à 30 broches (ESP32s et similaire) fera très bien le job pour notre application de CNC (ex chez Banggood). Il dispose en effet, comme tous les plus petits modules de suffisamment de mémoire pour GRBL.

Pré requis

Comme on ne change pas une équipe qui gagne (cf articles précédents...), le couple Visual Studio Code / Platformio sera utilisé pour compiler GRBL/ESP32.

Installer et lancer Visual Studio Code ( https://code.visualstudio.com/ )
Faire SHIFT+ CTRL + X pour accéder (ou menu View / Extensions) pour accéder au menu d'installation / gestion des extensions
Rechercher Platformio IDE, et l'installer
Installer un client GIT (exemple de client graphique pour Windows : https://tortoisegit.org/ ou de client en ligne de commande: https://git-scm.com/download/win )

Récupération des sources

Lancer un explorateur de fichiers et coller "%UserProfile%\Documents\PlatformIO\Projects" dans l'URL. C'est l'adresse ou Plaformio range par défaut ses projets

Faire bouton de droite dans ce répertoire et sélectionner "Git Clone" en indiquant l'adresse https://github.com/bdring/Grbl_Esp32 ou cloner le projet en ligne de commande.

Au bout de quelques secondes les sources sont rapatriées et sont rangées dans "%UserProfile%\Documents\PlatformIO\Projects\grbl_esp32"

Structure de GRBL_ESP32:

Pour en examiner sa structure, nous allons ouvrir le projet dans Visual Studio Code. Ouvrir Visual Studio Code, attendre que l'extension Platformio se charge, et dans l'onglet PIO Home faire "Open Project".

Dans "Documents\Platformio\projects\grbl_esp32", faire "open folder".

La partie gauche de la fenêtre matérialise l'organisation du projet :

.github\ : répertoire interne à Git, qui sert à garder trace des différentes versions. Ne sera pas utilisé par VS Code / Platformio. Ne pas supprimer.
.pio\ : répertoire qui servira à platformio à compiler le projet et contiendra le binaire compilé. EN cas de suppression sera automatiquement recréé lors de la compilation.
.vscode\ : répertoire interne à Visual Studio Code. Ne pas supprimer.
doc\ : Répertoire contenant les codes d'alarme, d'erreur, les options de build, et surtout les différents codes de contrôles qui sont étendus sur ESP32 par rapport à la version standard.
embedded\ : répertoire contenant l'interface web minimaliste (celle qui sera embarquée dans la rom), ses sources et de quoi la fabriquer.
grbl_esp32\ : Les sources de GRBL à proprement parler. C'est dans ce répertoire que se trouvent les fichiers à configurer avant de compiler et d'envoyer à la carte.
libraries\ : Répertoire qui contiendra les bibliothèques requises pour la compilation (téléchargées automatiquement lors de la 1ère compilation)
.gitattributes : utilisé en interne par Git. Ne pas supprimer.
.gitignore : utilisé en interne par Git. Ne pas supprimer.
.travis.yml : fichier de configuration de l'outil d'intégration continue TravisCI. Ne pas supprimer.
commands.sh : fichier bash de compilation (linux ou OSX) en utilisant l'environnement arduino. Ne sera pas utilisé dans notre méthode de compilation.
LICENCE : Copie de la license du logiciel (GNU GPL V3.0)
platformio.ini : Fichier contenant le projet platformio
README.md : Documentation générale. Une fois ouvert, peut être visualisé avec CTRL+K puis v

Choix d'un brochage

Le choix du brochage ne doit pas être fait par hasard. La complexité interne de l'ESP32 et les nombreux modes de fonctionnement font que certaines broches ont plusieurs fonctions, et notamment au boot de la carte. Ceci conduit à éviter certaines utilisations de certaines broches, ainsi paramétrées elles peuvent soit empêcher le boot, voir la programmation de la carte.

Un chapitre de la documentation y est dédié : https://github.com/bdring/Grbl_Esp32/wiki/Setting-Up-the-I-O-Pins

Le répertoire Grbl_Esp32\Machines contient différents brochages mis en œuvre par Bart Ding. J'ai choisi le brochage mpcnc_v1.2.h .

J'en ai découvert quelques limitations que je vais tenter d'expliquer :

GPIO2 doit être une sortie ou rester inutilisé : Pas de soucis, il est connecté sur "Spindle" c'est à dire une broche qui est une sortie.
GPIO12: Au boot doit être impérativement maintenu à l'état bas. Il est utilisé en "XStep" (pas de l'axe X). Le composant ESP32 dispose d'un pulldown interne de 51K. Lorsque non branché pas de soucis, la carte boote. Par contre selon ce que l'on raccorde comme driver, cela peut ne plus booter. Il faut s'intéresser au schéma interne ce que que l'on raccorde. Avec un driver Pollolu DRV8825 par exemple, les entrées STEP et DIR sont munies d'un pulldown interne de 100K. Pas de soucis. Si par contre on met un driver externe de type TB6600, il y a un pullup de 10K... Dans ce cas, l'effet du pullup de 10K peut être contré en ajoutant un pulldown de 1K directement sur la broche GPIO12. C'est facile à diagnostiquer : si après avoir terminé votre câblage, cela ne boote plus, il faut déconnecter GPIO12. Si cela refonctionne, il faut mettre le pulldown...
GPIO15: munie d'un pullup, mais si mise à l'état bas pendant le boote, rend muet le boot (plus de messages). Dans ce brochage il est utilisé en limite Z. Il vaut donc mieux y raccorder des fins de coures qui envoient un 0V lorsque actionnés....
GPIO34/35/36/39 : utilisées en entrées, ces broches devront être équipées d'un pullup de 10K

Je vous recommanderais plutot le brochage 3axis_v4.h, mieux documenté. Un prototype peut être câblé selon le schéma suivant : https://github.com/bdring/Grbl_ESP32_Development_Controller/blob/master/docs/V4p1/esp32_cnc_test_v4.1_schm.pdf ou cette carte peut être achetée en ligne sur la boutique Tindie de Bart: https://www.tindie.com/stores/33366583/ . Il n'y a pas souvent du stock... donc à suivre.

Dans mon cas, j'ai câblé une carte d'adaptation qui accepte un ESP32, un socket carte SD, une carte fille Arduino CNC Shield de Protoneer et une carte Relais. Cela a permis de réduire drastiquement le câblage (notamment pas l'emploi de la Shield Protoneer...). N'oublions pas qu'il s'agit d'un simple proto de validation du code.. OK, c'est moche, mais ca marche et cela supporte :

3 moteurs pas à pas 2.5A max aux 1/32e de pas.
Le chargement et le streaming des fichiers à partir de la carte SD
La commande d'une broche avec un relais 220V / 4A
Alimentation 19V (via une alimentation de PC)
3 fins de courses
Un détecteur de longeur d'outil
Une sortie PWM pour faire des essais avec un laser

Paramétrage des sources pour le proto

Énormément de choses sont paramétrables avant compilation. Les réglages par défaut ne sont pas idiots, mais je vous encourage vivement à lire attentivement le fichier config.h qui regorge de commentaires..

Brochages

Comme vu précédemment, j'ai choisi le brochage "3axis_V4.h" qui est identique à celui utilisé sur la carte prototype de Bart Ding.

Son activation se fait dans le fichier "machine.h" :

//#include "Machines/test_drive.h"
#include "Machines/3axis_v4.h"

Dans le cas ou vous auriez besoin de personnalisation avancée, le plus sage est de copier ce fichier et de mettre un nom à votre sauce, ou mieux de prendre custom_machine_template.h comme modèle. Il est possible de piloter des lasers, d'utiliser des cinématiques particulières (ex : corexy), donc il y a de quoi faire :). S'inspirer des autres fichiers de config également.

Différents choix s’offrent ensuite à vous en fonction de l'utilisation qui sera faite du contrôleur.

Cycle d'initialisation (Homing Cycle) :

Le fichier confiih.h vous permet de configurer cette fonctionnalité. Par défaut, c'est Z qui est homé d'abord puis X, puis Y.0

#define HOMING_CYCLE_0 (1<<Z_AXIS)	// TYPICALLY REQUIRED: First move Z to clear workspace.
#define HOMING_CYCLE_1 (1<<X_AXIS)
#define HOMING_CYCLE_2 (1<<Y_AXIS)

Il peut être possible de homer X et Y simultanément :

#define HOMING_CYCLE_0 (1<<Z_AXIS)                // REQUIRED: First move Z to clear workspace.
#define HOMING_CYCLE_1 ((1<<X_AXIS)|(1<<Y_AXIS))  // OPTIONAL: Then move X,Y at the same time.

Ou pour une laser, de homer X puis Y sans toucher à Z :

// For Laser
// #define HOMING_CYCLE_0 (1<<X_AXIS)  // COREXY COMPATIBLE: First home X
// #define HOMING_CYCLE_1 (1<<Y_AXIS)  // COREXY COMPATIBLE: Then home Y

Petite astuce... Si comme moi vous préférez travailler dans un espace orthonormé avec des valeurs positives (par défaut, les déplacement se font en mouvement négatif, comme sur les machines professionnelles), il fait décommenter ceci dans config.h :

#define HOMING_FORCE_SET_ORIGIN // Uncomment to enable.

Par ailleurs, pour un laser, il peut être indispensable de commenter la ligne suivante pour désactiver le laser avec SPINDLE ENABLE:

//#define SPINDLE_ENABLE_OFF_WITH_ZERO_SPEED

Compilation et envoi à la carte de développement

L'environnement de développement ayant déjà été paramétré, la compilation se fait simplement par le menu PlatformIO > Build. Lors de la première compilation, il n'est pas impossible qu'un certain nombre de dépendances doivent se télécharger.

A l'issue, la fenetre du terminal de Code / Plaformio devrait afficher :

Compiling .pio\build\nodemcu-32s\FrameworkArduino\main.cpp.o
Compiling .pio\build\nodemcu-32s\FrameworkArduino\stdlib_noniso.c.o
Compiling .pio\build\nodemcu-32s\FrameworkArduino\wiring_pulse.c.o
Compiling .pio\build\nodemcu-32s\FrameworkArduino\wiring_shift.c.o
Archiving .pio\build\nodemcu-32s\libFrameworkArduino.a
Linking .pio\build\nodemcu-32s\firmware.elf
Retrieving maximum program size .pio\build\nodemcu-32s\firmware.elf
Building .pio\build\nodemcu-32s\firmware.bin
Checking size .pio\build\nodemcu-32s\firmware.elf
Advanced Memory Usage is available via "PlatformIO Home > Project Inspect"
RAM:   [==        ]  21.5% (used 70348 bytes from 327680 bytes)
Flash: [========= ]  91.1% (used 1791034 bytes from 1966080 bytes)
esptool.py v2.6
==================================================================================== [SUCCESS] Took 113.25 seconds ====================================================================================

Terminal will be reused by tasks, press any key to close it.

Vous devriez maintenant pouvoir envoyer à la carte avec PlatformIO / Upload. A noter lors de vos prochaines compilations, que vous pouvez directement utiliser ce dernier menu pour compiler et envoyer à la cible.

Première mise en service

Setup du Wifi ... par Wifi.

Il y a plusieurs méthodes pour mettre en service la carte. Lors de sa première programmation, aucun paramètres réseau n'étant présent, elle se met en point d'accès. La méthode de base est donc de connecter votre ordinateur au point d'accès GRBL_ESP, et d'ouvrir une page web sur la config...

Je ne suis pas fan de la méthode, même si cela dépanne. En effet, si l'ordinateur avec lequel vous faites cela n'a pas de wifi, c'est mort...

Ou setup du wifi par commandes série

Par contre, la carte est toujours connectée à l'ordinateur par le câble USB.. et on va pouvoir s'y connecter par le port série virtuel...

Pour ce faire, il existe un moniteur série dans PlatformIO. Il est accessible dans la barre d'outils tout en bas. Cliquez sur (1) pour le lancer. En (2) vous devriez vous la bannière de GRBL :

Nous allons utiliser des commandes spéciales documentées dans https://github.com/bdring/Grbl_Esp32/blob/master/doc/Commands.txt afin de configurer le wifi.

Setup Wifi en mode client et DHCP

[ESP110]STA
[ESP100]MON_SSID_PERSO
[ESP101]MON_DE_PASSE_PERSO
[ESP102]DHCP

Ou si vous le souhaitez setup du Wifi en mode IP Fixe

[ESP110]STA
[ESP100]MON_SSID_PERSO
[ESP101]MON_DE_PASSE_PERSO
[ESP102]STATIC
[ESP103] IP=192.168.20.21 MSK=255.255.255.0 GW=192.168.20.254

Vous pouvez ensuite vérifier vos paramètres réseau

[ESP103]
[ESP111]

Lors d'une première utilisation, ou si vous avez fait une mise à jour majeure il peut être nécessaire de reformater la flash :

[ESP710]FORMAT

Et redémarrer l'ESP :

[ESP444]RESTART

Première connexion au WIfi

Maintenant que votre carte est associée au réseau Wifi, vous pouvez vous y connecter ( http://grblsesp.local ou http://ip_mise_dans_votre_esp ). La page d'accueil vous indique que l'interface n'est pas chargée :

Le fichier est fourni avec GRBL ESP32 dans le répertoire grbl_esp32\data. Il suffit de l'uploader avec l'interface web. Le fichier favicon peut être uploadé également. Une fois ces 2 fichiers présents, un nouveau bouton "Go to ESP3D Interface" apparait. CLiquez dessus pour basculer sur l'interface graphique.

Voici ce que vous devriez obtenir (ici après un appui sur refrech sur la carte SD, qui montre les fichiers installés dessus)

Fonctionnement normal

Par défaut, la carte attend un homing des axes. Tant que ce n'est pas fait, la machine est stoppée en "erreur" (icône rouge en forme de cloche). Il est possible d'acquitter cette "erreur" en cliquant sur la cloche afin de poursuivre les tests sans activer les fins de couses. Il est également possible de le couper dans la configuration par la commande $22 ($22=0). Plus d'infos sur les commandes de GRBL dans https://github.com/gnea/grbl/wiki/Grbl-v1.1-Configuration#grbl-settings.

A ce stade il va vous falloir paramétrer GRBL sur votre machine et vos moteurs (nombre de pas par mm, etc..), avant de pouvoir jouer avec. Sur ce blog et sur d'autres beaucoup d'informations sont données sur la logique de paramétrage. A ce stade, c'est du GRBL "classique", donc je vous laisse vous documenter.

Ce qui l'est moins est l'interface Web et la carte SD. Vous allez pouvoir mettre des fichiers Gcode sur la carte SD en les copiant sur PC ou mac par exemple, mais aussi en les uploadant à partir de l'interface.

Ensuite vous pourrez les exécuter en affichant le contenu de la carte SD et en appuyant sur play en face du fichier considéré. Magique!!!! Une machine en Wifi!!!

Limites et notes importantes

Je n'ai pas tout testé car honnêtement, c'est énorme ce que GRBL ESP32 peut faire. Streaming bluetooth à partir d'un téléphone, support des drivers Trinamic en mode SPI chainés... Pour ce que j'ai testé, c'est très largement suffisant pur faire fonctionner une petite machine de CNC.

Coté limitations c'est assez light :

La carte est en 3.3V, il faut donc passer par une logique d’adaptation pour connecter des sorties 5V sur les entrées sous peine de destruction.
Pas de https. On aurait pu imaginer, vu qu'il y a possibilité de mettre nu mot de passe, que celui-ci soit chiffré. C'est une remarque assez globale sur les ESP (8266 ou 32).
Impossibilité de préciser la polarité de la commande de relais de Spindle, qui est toujours en logique positive (1=3.3V=On). Il faut donc mettre un petit transistor externe si on veut en inverser le sens.

Le futur de GRBL sur ESP32

Bart Ding s'est fait un planning de fonctionnalité (Road Map) de malade. Pour suivre le projet je peux vous dire qu'il avance brillamment le bougre.. Visible ici : https://github.com/bdring/Grbl_Esp32/wiki/Development-Roadmap.

Pour le fun

La marche de l'empereur sur ESP32...

Civade.com