Découpeuse laser Electronique Software

Installation du logiciel GRBL ESP32

Written by Avataar120

Ce tutoriel couvre l’installation de GRBL pour ESP32 même si vous n’avez pas acheté mon shield laser.
En revanche, les chapitres sur les paramétrages seront adapté à mon shield, il faudra faire des modifs si vous utilisez un autre shield !

Compilation de GRBL ESP32 :

Préparation de l’environnement de compilation

  • Installez la dernière version de l’IDE Arduino (lien)
  • Téléchargez la dernière version (version >= 871 sinon pb de stabilité USB) de GRBL ESP32 (lien), si vous n’êtes pas familier de Github suivre les instructions ci-dessous :
    • Cliquez sur le bouton vert “Code”
    • Choisissez “Download Zip”
    • Décompressez le zip dans le répertoire de vos projets Arduino (en général Documents/Arduino)
  • Installez les librairies nécessaires :
    • Deux sont fournies dans le zip de GRBL ESP32 : ArduinoWebSockets et ESP32SSDP
      Copiez les deux librairies (situés dans le répertoire dézippé dans le répertoire “librairies” dans le répertoire des librairies arduino sur votre PC : en général dans Documents/Arduino/librairies
    • La troisième TMCStepper doit être installée via le gestionnaire de librairies de l’IDE arduino :
      Menu Croquis/Inclure une librairie/Gérer les librairies (ou CTRL+MAJ+I)
      Chercher TMCStepper et l’ajouter en cliquant sur installer
  • Installez les fichiers des cartes ESP32 dans l’IDE Arduino :
    • Dans le menu Fichier/Préférences, mettre la ligne https://dl.espressif.com/dl/package_esp32_index.json dans la ligne “URL de gestionnaire de cartes supplémentaires” et cliquez sur OK
    • Dans le menu Outils/Type de carte/Gestionnaire de carte, cherchez ESP32 et installer le gestionnaire associé en version <= 1.0.4 (les version 1.0.5 et 1.0.6 ont un bug sur la connexion série over USB)
    • Dans le menu Outils/Type de carte/ESP32 Arduino, choisir “ESP 32 Dev Module”
    • Dans le menu Outils/Type de Carte/Partition Scheme, choisir “Minimal SPIFFS”
    • Votre paramétrage doit ressembler à ça :
GRBL ESP32 - Configuration IDE Arduino

Paramétrage de GRBL ESP32 :

Ce logiciel a été conçu pour piloter de très nombreuses machines différentes et en particulier les CNC et les machines laser.

Il faut donc modifier quelques fichiers de paramétrage avant de compiler GRBL ESP32.

Configurer votre machine :

Dans le répertoire dézippé contenant GRBL ESP32, allez dans le répertoire GRBL_ESP32/src/Machines

Créez un fichier nommé “K40_AvaShield.h” par exemple

Y intégrer les lignes suivantes (si vous avez mon shield, sinon il faudra adapter)

#define MACHINE_NAME            "K40_AvaShield" //Mettre le nom que vous souhaitez pour votre machine

#define X_STEP_PIN              GPIO_NUM_12
#define X_DIRECTION_PIN         GPIO_NUM_14
#define Y_STEP_PIN              GPIO_NUM_26
#define Y_DIRECTION_PIN         GPIO_NUM_15
#define Z_STEP_PIN              GPIO_NUM_27
#define Z_DIRECTION_PIN         GPIO_NUM_33
#define STEPPERS_DISABLE_PIN    GPIO_NUM_13

#define X_LIMIT_PIN             GPIO_NUM_17
#define Y_LIMIT_PIN             GPIO_NUM_4
#define Z_LIMIT_PIN             GPIO_NUM_16

#define SPINDLE_TYPE            SpindleType::LASER
#define LASER_OUTPUT_PIN 	GPIO_NUM_2
#define LASER_ENABLE_PIN 	GPIO_NUM_22

#define COOLANT_MIST_PIN        GPIO_NUM_21  // labeled Air_Assist
#define INVERT_COOLANT_MIST_PIN

#define COOLANT_FLOOD_PIN       GPIO_NUM_25  // labeled Coolant
#define PROBE_PIN               GPIO_NUM_32  // labeled Probe

#define DEFAULT_HOMING_CYCLE_0      			((1<<X_AXIS)|(1<<Y_AXIS))
#define DEFAULT_HOMING_CYCLE_1      			(1<<Z_AXIS)
#define INVERT_LIMIT_PIN_MASK 				(bit(X_AXIS)|bit(Y_AXIS))

#define DEFAULT_INVERT_SPINDLE_ENABLE_PIN		1 //L'alimentation des K40 effectue le tir laser sur un état bas. Si votre alim tire sur état haut, ne pas mettre cette ligne

#define DEFAULT_INVERT_PROBE_PIN 			1

#define CONTROL_SAFETY_DOOR_PIN GPIO_NUM_35  // labeled Door, peut poser problème sur certaines version des ESP32
#define CONTROL_RESET_PIN       GPIO_NUM_34  // labeled Reset,
#define CONTROL_FEED_HOLD_PIN   GPIO_NUM_36  // labeled Hold, 
#define CONTROL_CYCLE_START_PIN GPIO_NUM_39  // labeled Start,

Attention, la PIN safety DOOR peut vous empêcher de communiquer via la liaison série avec GRBL tant que l’ESP32 n‘est pas sur le shield (pas systématique et dépend des ESP32)
Deux possibilités :

  • Commenter la ligne #define CONTROL_SAFETY_DOOR_PIN … le temps de faire vos réglages si vous n’avez pas encore assemblé votre shield puis la décommenter quand vous aurez votre shield
  • Installer l’ESP32 sur son shield dès la fin du téléversement du logiciel via l’IDE Arduino (voir plus bas)

Intégration de ce fichier au projet ESP32 :

Modifiez le fichier machines.h situé dans le répertoire GRBL_ESP32/src/ pour y faire figurer le fichier de paramétrage que nous venons de créer :

Sous la directive : #ifndef MACHINE_FILENAME, remplacez le #include “Machines/test_drive.h” par :

#include "Machines/K40_AvaShield.h" //modifier le nom pour matcher avec le nom de fichier que vous avez créé juste au dessus

Modification des paramètres généraux de GRBL ESP32:

Nous allons modifier deux paramètres dans le fichier config.h de GRBL ESP32 pour prendre en compte deux éléments :

  • Il n’y a pas de SD Card sur mon Shield
  • La vitesse de la liaison série over USB – Je mets personnellement 921600bauds en vitesse de communication. Mais ça peut générer deux problèmes :
    1. Impossible de se connecter à l’ESP32 avec la console Arduino – donc pour la première configuration ce n’est pas l’idéal – Seul Lightburn est paramétré pour se connecter à cette vitesse
    2. Vous pouvez avoir des déconnexions USB – A tester donc.

Commentez la ligne #define ENABLE_SD_CARD :

//#define ENABLE_SD_CARD

//#define BAUD_RATE 921600
#define BAUD_RATE 115200

Compilation de GRBL ESP32 :

Il ne reste presque plus rien à faire !

Ouvrez le fichier GRBL_ESP32/Grbl_Esp32.ino dans l’IDE Arduino (Fichier/Ouvrir)

Et cliquez sur l’icone “Vérifier”

La compilation peut prendre quelques minutes.

Si tout se passe bien, vous ne devriez avoir que des warnings de compilation (en particulier si vous avez plusieurs librairies installées pour certains modules). Le message final devrait ressembler à cela :

Le croquis utilise 1824342 octets (92%) de l'espace de stockage de programmes. Le maximum est de 1966080 octets.
Les variables globales utilisent 69252 octets (21%) de mémoire dynamique, ce qui laisse 258428 octets pour les variables locales. Le maximum est de 327680 octets.

Téléversement de GRBL ESP32 dans l’ESP32

Il ne reste plus qu’à téléverser le logiciel compilé dans l’ESP32.

Pour cela, il ne faut pas que l’ESP 32 soit monté sur le shield.
Il ne faut pas non plus qu’un logiciel utilisant le port série soit lancé (genre lightburn par exemple)
Une fois le premier SW chargé dans l’ESP32, il sera ensuite possible de le mettre à jour SUR le shield via la mise à jour over the air (via l’interface web de GRBL ESP32) – voir chapitre mise à jour OTA plus bas

Branchez l’ESP32 via un cordon USB à votre PC.
Vérifiez dans le menu Outils/Port qu’un port série est bien connecté – sinon sélectionner le port COM affiché dans le sous menu.

Lancez le téléversement en cliquant sur l’icone Téléverser de l’IDE
Au bout de quelques secondes, vous devriez avoir des messages dans la console indiquant des écritures “Writing at 0x00xxx000…. (XX%)” puis le message final :

Wrote 3072 bytes (129 compressed) at 0x00008000 in 0.0 seconds (effective 2730.6 kbit/s)...
Hash of data verified.

Leaving...
Hard resetting via RTS pin...

A ce stade, si vous avez déjà votre shield, vous pouvez monter votre ESP32 sur le shield (en n’oubliant pas au préalable de déconnecter l’ESP32 de votre ordinateur pour qu’il ne soit pas alimenté au moment de l’insertion dans le shield)
Pas besoin d’alimenter le shield via une alimentation externe, l’alimentation via le port USB de votre ordinateur est suffisante pour faire fonctionner le shield pour tous vos réglages / vérifications avant montage dans la K40

Configuration wifi

Vous pouvez d’ors et déjà régler vos paramètres wifi via la console de l’IDE Arduino si vous avez choisi une vitesse de communication standard pour le BAUD_RATE dans le fichier config.h.
Dans le cas contraire, il faudra le faire via la console WebUI accessible en Wifi (Access point automatiquement créé par GRBL ESP32 lors de la première installation, adresse de connexion 192.168.0.1)

Pour cela, entrez la commande :

$s

Vous devriez voir la liste de tous les paramètres étendus de GRBL (par rapport à la version originale de GRBL, la version ESP32 permet de régler beaucoup de paramètres après avoir compilé GRBL)

Entrez les commandes suivantes :

$Sta/SSID=Votre_SSID_WIFI
$Sta/Password=Votre_Password_tres_tres_secret (8 caractères mini)
$Sta/IPMode=DHCP
$Radio/Mode=STA

Appuyez maintenant sur le bouton “RESET” situé à côté du port USB de votre ESP32 et vous devriez voir dans la console le message suivant :

[MSG:Connecting..]
[MSG:Connecting...]
[MSG:Connected with 192.168.5.30]
[MSG:Start mDNS with hostname:http://grblesp.local/]
[MSG:SSDP Started]
[MSG:HTTP Started]
[MSG:TELNET Started 23]
[MSG:Flood coolant on pin GPIO(25)]
[MSG:Mist coolant on pin GPIO(21)]
[MSG:X  Axis limit switch on pin GPIO(17)]
[MSG:Y  Axis limit switch on pin GPIO(4)]
[MSG:Z  Axis limit switch on pin GPIO(16)]
[MSG:Probe on pin GPIO(32)]

Grbl 1.3a ['$' for help]

Votre GRBL est désormais connecté en Wifi et vous pouvez vous connecter à l’adresse IP fournie par votre routeur ou via l’adresse : http://grblesp.local/

Vous devriez voir la page suivante :

Il faut maintenant installer l’interface utilisateur de GRBL.
Pour cela, il suffit de cliquer sur “Select. Fichiers” et aller cherche le fichier GRBL_ESP32/data/index.html.gz

Puis cliquez sur “Upload” et enfin cliquez sur “Go to ESP32 Interface”

Ce qui devrait vous emmener sur l’interface web de GRBL :

Configuration GRBL pour la K40

La K40 n’est équipée de moteurs pas à pas et de poulies standards.

En effet, quand les moteurs pas à pas classiques sont des 1,8° par step, soit 200 steps pour un tour, les moteurs de la K40 sont deux fois plus résolus avec 0,9° par step, soit 400 steps pour un tour

Quand les poulies et courroies classiques sont des BT2 (chaque dent fait 2mm), sur la K40, en général, ce sont des poulies et courroies MXL dont le pas est de 2.032mm
Les poulies ont 20 dents.

GRBL a besoin de savoir combien de steps sont nécessaires pour faire un millimètre.

Suivant votre configuration de microsteps choisie (voir article : nouvelle électronique pour K40), le nombre de steps sera différent :

La formule est simple : NbStepPour1mm = 400/40,64 * NbMicroStepParStep

Nombre de microstep pour 1 stepNombre de step pour 1 mm
19,84
219,69
439,37
878,74
16157,48
32314,96

On va donc rentrer ces réglages pour l’axe des X et des Y (fonction de votre choix de microsteps).
Si vous avez retenu 4 microsteps pour 1 step (soit 1/4ème), voici ce qu’il faudra entrer dans la console de l’interface Web :

$X/StepsPerMm=39.37
$Y/StepsPerMm=39.37

Reste à régler les accélérations, vitesses max et distances de trajet autorisées (les vitesses sont en mm/min):

$X/Acceleration=3000.000
$Y/Acceleration=3000.000

$X/MaxRate=20000.000
$Y/MaxRate=20000.000

$X/MaxTravel=300.000
$Y/MaxTravel=210.000

Pour l’axe Z, si vous avez un lit motorisé du type de celui de JP. Civade avec 1/4 de steps :

$Z/StepsPerMm=1000
$Z/MaxRate=100.000
$Z/Acceleration=500.000
$Z/MaxTravel=20.000

Et maintenant, d’autres réglages plus généraux :

Ne pas mettre les parenthèses :)

$Stepper/Pulse=10          (Durée du pulse pour un microstep)
$Stepper/IdleTime=255      (Durée de maintien des moteurs après un mouvement, 255 pour         bloquer les moteurs indéfiniment ... Attention, ça peut chauffer)

$Limits/Invert=On          (Les capteurs de fin de course sont NF)
$Probe/Invert=On           (La probe a une pull-up sur la carte)

$Report/Status=2           (Important dans le cadre d'un lit motorisé, renvoie les coordonnées de travail et non pas les coordonnées absolues de la machine)

$Limits/Soft=Off           (A activer si vous voulez interrompre le travail en cas de coordonnées supérieures aux coordonnées max données dans X/MaxTravel et Y/MaxTravel)
$Limits/Hard=On            (Arrête le travail si les fins de course sont atteintes)

$Homing/Enable=On          (Active la fonction Homing - retour à l'origine)

$Homing/DirInvert=XY       (Inverse la direction de homing des axes X et Y - dépend de votre cablage, voir article sur la première mise sous tension)
$Homing/Feed=200.000       (Vitesse de homing lors du 2ème mvt - déplacement lent)
$Homing/Seek=2500.000      (Vitesse de homing lors du 1er mvt - déplacement rapide)
$Homing/Debounce=25.000    (Temps pour valider un changement de valeur de butée)
$Homing/Pulloff=5.000      (Mouvement de retrait sur tous les axes suite à un homing)

$Homing/Cycle1=Z           
(Homing du bed après homing XY. Si pas de bed mettre $Homing/Cycle1=)

$GCode/LaserMode=On        (Active le mode laser - qui change le comportement de GRBL sur plusieurs sujets)

$Spindle/PWM/Frequency=15000.000 (Fréquence du PWM pilotant la puissance du laser)

Chaque commande entrée doit être acquitté par GRBL par un “ok”

Vous pouvez vérifier la bonne prise en compte des paramètres grâce à la commande :

$s

Vous avez maintenant terminé l’installation de GRBL pour ESP32 ! Bravo !

Mise à jour OTA :

S’il n’est pas possible de téléverser une mise à jour de GRBL pour ESP32 via l’interface Arduino si votre ESP32 est monté sur le shield, il est en revanche possible de le mettre à jour over the air ou OTA (via wifi) même s’il est monté sur le shield.

Pour cela, il faut d’abord savoir où Arduino IDE stocke le logiciel compilé de GRBL.
Il faut activer les options suivantes dans le menu “Fichier/Préférence” :

Ensuite, il suffit de compiler GRBL via Arduino IDE et à la fin de la compilation, il est indiqué le répertoire contenant le fichier binaire à télécharger via OTA

C:\\Users\\XXX\\AppData\\Local\\Temp\\arduino_build_977474/Grbl_Esp32.ino.elf

Le fichier binaire sera donc situé dans le répertoire c:\users\VotreNom\AppData\Local\Temp\arduino_build_XXXXX

Lancez l’interface WEB de GRBL via l’adresse IP donnée par votre routeur ou en tapant http://grblesp.local/

Sélectionnez le menu ESP3D puis cliquez sur l’icone du nuage orange

Il ne reste plus qu’à sélectionner le fichier Grbl_Esp32.ino.bin situé dans le répertoire précédemment cité

Après le téléchargement, l’ESP32 et l’interface WEB redémarrent tous seuls.

Troubleshooting

Si votre ESP32 n’est pas détecté lors de la connexion USB, il se peut que ça provienne de votre driver USB.

Sous windows en particulier, il peut être nécessaire de remettre le driver USB dans une ancienne version pour que la liaison série over USB fonctionne correctement.

Lien vers la bonne version du driver USB : lien

About the author

Avataar120

Leave a Comment

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.