Utilisation de GRBL 1.1

(Section : "Les tutoriaux")
5

Utilisation de GRBL 1.1

Article publié le Mardi 05 novembre 2024 , lu 18 fois

Illustration : Utilisation de GRBL 1.1

Utilisation de GRBL 1.1

Tout d’abord, connectez-vous à GRBL en utilisant le terminal série de votre choix. Définissez le débit en bauds sur 115200 sur 8-N-1 (8 bits, pas de parité et 1 bit d’arrêt). Une fois connecté, vous devriez obtenir l’invite GRBL, qui ressemble à ceci :

GRBL 1.1* ['$' pour l’aide]

Taper $ et appuyez sur Entrée pour que GRBL imprime un message d’aide. GRBL devrait répondre par :

Les commandes '$' sont des commandes système GRBL utilisées pour modifier les réglages, afficher ou modifier les états et les modes de fonctionnement de GRBL et démarrer un cycle de ralliement. Les quatre dernières commandes non-'$' sont des commandes de contrôle en temps réel qui peuvent être envoyées à tout moment, peu importe ce que fait GRBL. Ceux-ci modifient immédiatement le comportement de course de GRBL ou impriment immédiatement un rapport des données importantes en temps réel comme la position actuelle (alias DRO). 

$$ - Voir les paramètres GRBL

Pour afficher les paramètres, tapez $$ et appuyez sur Entrée après la connexion à GRBL. GRBL devrait répondre avec une liste des paramètres système actuels, comme indiqué dans l’exemple ci-dessous. Tous ces paramètres sont persistants et conservés dans EEPROM, donc si vous éteignez, ils seront chargés à nouveau la prochaine fois que vous allumerez votre Arduino.

$0 - Impulsions de pas (en microsecondes)

Les moteurs pas-à-pas sont conçus pour une certaine longueur minimale d’impulsions de pas. L’idéal est d’avoir les impulsions les plus courtes que vos moteurs peuvent reconnaître de manière fiable. Si elles sont trop longues, les impulsions de pas peuvent commencer à se chevaucher.

Valeur par défaut : $0=10

$1 - Délais d'attente de pas (millisecondes)

Chaque fois que vos moteurs pas-à-pas complètent un mouvement et s’arrêtent, GRBL va retarder leur désactivation par cette valeur. Selon votre machine, vous pouvez :

Attention, certains pilotes pas à pas ne se souviennent pas à quel micro-pas ils se sont arrêtés, alors quand vous les réactivez, vous pouvez être confronté à une perte de pas. Dans ce cas, il suffit de garder vos moteurs activés en permanence.

Valeur par défaut : $1=25 

$2 - Inversion du signal d'impulsion de pas (masque - binaire)

Ce paramètre inverse le signal d’impulsions de pas.

Par défaut, un signal de pas commence à un niveau bas et va vers le haut lors d’un événement d’impulsions de pas. Après un temps d’impulsions de pas fixé par $0, il se réinitialise au niveau bas, jusqu’au prochain événement d’impulsion de pas. Quand il est inversé, le comportement de l’impulsion de pas passe du niveau haut, au niveau bas pendant l’impulsion, et retourne au niveau haut.

Ce paramètre n’est pas utile pour la plupart des utilisateurs, mais cela peut être utile pour certains moteurs pas à pas qui ont des exigences particulières. Pour inverser le signal d’impulsion d’un ou plusieurs axes, il vous suffit de suivre les informations du tableau ci-dessous. Exemple : pour inverser les axes X et Z, écrivez $2=5 et tapez sur entrée.

Inversion des axes
Figure 1 : Inversion des axes

Valeur par défaut : $2=0 

$3 - Inversion de la direction des axes (masque - binaire)

De base le paramètre est sur 0. Si un ou plusieurs axes sont inversés, changez le paramètre en suivant le tableau ci-dessous.

Exemple : pour inverser les axes Y et Z, écrivez $3=6 et tapez sur entrée.

Inverser la direction des axes
Figure 2 : Inverser la direction des axes

Valeur par défaut : $3=0

$4 - Inversion du signal d'activation (booléen)

Par défaut, l’activation se fait vers le haut pour désactiver et vers le bas pour activer. Si votre configuration a besoin de l’inverse, il suffit de taper $4=1.

Vous devez redémarrer après avoir changé ce paramètre.

Valeur par défaut : $4=0 

$5 - Inversion du type de contact des fins de courses (Boolean)

Par défaut, les broches de limites sont maintenues au niveau haut via une résistance « pull-up » interne à l’Arduino.

Si vous utilisez des interrupteurs de fin de course de type « NO » (normalement ouvert), les actionner correspond à passer au niveau bas.

Si vous utilisez des interrupteurs de fin de course de type « NF » (normalement fermé), il va falloir inverser en passant ce paramètre à 1.

Attention, il va aussi falloir ajouter des résistances « pull-down » externe.

Vous devez redémarrer après avoir changé ce paramètre.

Valeur par défaut : $5=0

$6 - Inversion de la broche de sonde (Booléen)

Par défaut, la broche du Z-probe est maintenue au niveau haut via une résistance “pull-up” interne à l’Arduino.

Le capteur indique un niveau bas lors du contact de la pince (masse) avec la base du Z-probe, GRBL l’interprète comme déclenché.

Si vous avez besoin de l’inverse, il faut taper $6=1.

Attention, il va aussi falloir ajouter une résistance « pull-down » externe.

Vous devez redémarrer après avoir changé ce paramètre.

Valeur par défaut : $6=0 

$10 - Rapport de situation en temps réel (Masque - binaire)

Ce paramètre détermine les données que GRBL enverra en temps réel lorsque la commande « ? » est envoyée.

Par défaut GRBL envoie les données suivantes :

Le nouveau rapport de GRBL v1.1+ comprend à peu près tout dans le rapport d’état standard.

Une grande partie des données sont cachées et n’apparaîtront que si elles changent. Cela augmente considérablement l’efficacité par rapport à l’ancien style de rapport et permet d’obtenir des mises à jour plus rapides tout en obtenant plus de données sur votre machine.

Pour garder les choses simples et cohérentes, GRBL v1.1 n’a que deux options de rapport. Ceux-ci sont principalement ici juste pour les utilisateurs et les développeurs pour aider à mettre des choses en place.

Cela montre le nombre de blocs ou d’octets disponibles dans les buffers respectifs.

Ceci est généralement utilisé pour aider à déterminer comment GRBL fonctionne lors de l’essai d’une interface de streaming.

Pour activer/désactiver les options de rapports utilisez le tableau ci-dessous.

Rapport de situation en temps réel
Figure 2 : Rapport de situation en temps réel

Valeur par défaut : $10=1

$11 - Écart de jonction (millimètres)

L’écart de jonction est utilisé par le gestionnaire d’accélération pour déterminer à quelle vitesse il peut se déplacer à travers les jonctions du segment de ligne d’un chemin de programme G-code.

Par exemple, si le chemin a un virage serré de 10 degrés à venir et la machine se déplace à pleine vitesse, ce paramètre aide à déterminer combien la machine a besoin de ralentir pour passer en toute sécurité sans perdre de pas.

Plus la valeur est élevée, plus le mouvement sera rapide dans les virages, cela augmente le risque de perdre des pas.

Valeur par défaut : $11=0.010

$12 - Tolérance des arcs (millimètres)

Valeur par défaut : $12=0.002 

$13 - Unités des rapports d'état (booléen)

GRBL dispose d’une fonction de rapport de positionnement en temps réel pour fournir un retour d’information à l’utilisateur sur la position exacte de la machine à ce moment-là, ainsi que des paramètres pour les décalages de coordonnées et le palpage. Vous pouvez choisir de les afficher en millimètres ou en pouces.

Valeur par défaut : $13=0 

$20 - Limites logicielles (Booléen)

Les « soft limits » sont une fonction de sécurité qui aide à empêcher votre machine de se déplacer trop loin et au-delà des limites de déplacement.

Il fonctionne en connaissant les limites de course maximales pour chaque axe ($130, $131 et $132) et si le homing est activé ($22).

Chaque fois qu’un nouveau mouvement G-code est envoyé à GRBL, il vérifie si vous avez accidentellement dépassé l’espace de votre machine. Si vous le faites, GRBL stoppera tout (déplacement d’axes, broches et liquide de refroidissement), puis définira l’alarme du système indiquant le problème.

Valeur par défaut : $20=0

$22 - Cycle de homing (Booléen)

Le cycle de homing est utilisé pour localiser avec précision et précision une position connue et cohérente sur une machine à chaque fois que vous démarrez votre GRBL.

Utilité : Vous commencez à usiner quelque chose et le courant est coupé, vous redémarrez GRBL et GRBL n’a plus aucune idée de l’endroit où se trouve la broche. Embêtant n’est-ce pas…

Si vous avez fait un homing, vous avez toujours le point de référence zéro de la machine grâce à vos interrupteurs de fin de course. Il vous suffit donc de relancer un cycle de homing pour recalibrer la machine exactement comme avant la coupure de courant et reprendre là où vous vous étiez arrêté.

Pour utiliser le homing, vous aurez donc besoin d’interrupteurs de fin de course.

Par défaut, le cycle de homing déplace d’abord l’axe Z pour effacer l’espace de travail, puis déplace les axes X et Y en même temps.

Lorsque la prise d’origine est activée, GRBL verrouille toutes les commandes de G-code jusqu’à ce que vous exécutiez un cycle d’homing « $H ».

Valeur par défaut : $22=1

 

$23 - Inversion de direction du homing (Masque binaire)

Par défaut, GRBL suppose que vos commutateurs de limite d’homing sont dans la direction positive, déplaçant d’abord le z-axe positif, puis les axes x-y positifs avant d’essayer de localiser précisément la machine zéro en faisant des allers-retours lentement autour de l’interrupteur.

Si votre machine à un commutateur de limite dans la direction négative, le masque de direction d’homing peut inverser la direction des axes. Pour cela, changez le paramètre en suivant le tableau ci-dessous.

Exemple : pour inverser les axes Y et Z, écrivez $23=6 et tapez sur entrée.

Inversion de direction du homing
Figure 2 : Inversion de direction du homing

Valeur par défaut : $23=0

$24 - Vitesse d'avance du homing (mm/mn)

Le cycle de homing recherche d’abord les interrupteurs de fin de course à une vitesse plus élevée, et après les avoir trouvés, il se déplace à une vitesse d’avance plus lente pour revenir à l’emplacement précis du « zéro machine ».

La vitesse d’avance du homing est la vitesse d’avance la plus lente.

Réglez-le sur la valeur qui fournit une localisation du « zéro machine » répétable et précise.

Valeur par défaut : $24=25 

$25 - Vitesse de recherche du homing (mm/min)

Le cycle de homing recherche d’abord les interrupteurs de fin de course à une vitesse plus élevée, et après les avoir trouvés, il se déplace à une vitesse d’avance plus lente pour revenir à l’emplacement précis du zéro machine.

La vitesse de recherche du homing est la vitesse d’avance la plus élevée.

Ajustez la vitesse pour atteindre les interrupteurs de fin de course dans un temps assez court sans toutefois les écraser si le déplacement est trop rapide.

Valeur par défaut : $25=500

$26 - Antirebond de homing (millisecondes)

Chaque fois qu’un interrupteur se déclenche, il peut y avoir un bruit électrique / mécanique qui fait « rebondir » le signal haut et bas pendant quelques millisecondes (parasite électrique).

Pour résoudre ce problème, GRBL introduit un court délai pour laisser le signal rebondir pendant le homing lors de la localisation du « zéro machine ».

Dans la plupart des cas, 5 à 25 millisecondes fonctionnent très bien.

Valeur par défaut : $26=250

$27 - Retrait de sécurité du homing (mm)

Une fois la détection du point zéro d’un axe faite, il faut indiquer une distance de retrait pour éviter des déclenchements intempestifs.

1 ou 2 mm sont généralement suffisants.

Valeur par défaut : $27=1 

$30 - Vitesse maximum de la broche (tr/mm)

Définit la vitesse de rotation maximum à laquelle peut tourner votre broche à 5V.

Valeur par défaut : $30=1000

$31 - Vitesse minimum de la broche (tr/mm)

Définit la vitesse de rotation minimum à laquelle peut tourner votre broche à 0.02V. (0V = désactivé)

Valeur par défaut : $31=0

$32 - Mode Laser (booléen)

$32=1 : activer

  GRBL se déplace continuellement à travers des commandes de mouvement consécutives G1, G2 ou G3 lorsqu’il est programmé avec une vitesse de broche (puissance du laser). La broche PWM de la broche est mise à jour instantanément à chaque mouvement sans s’arrêter.

$32=0 : désactiver

  GRBL fonctionne comme il l’a toujours fait, il arrête le mouvement à chaque commande de vitesse de broche. Il s’agit du fonctionnement par défaut d’une fraiseuse pour permettre une pause afin de laisser la broche changer de vitesse.

Valeur par défaut : $32=0 

$100 $101 $102 - [X, Y, Z] (pas/mm)

Il s’agit du nombre de millimètres parcourus à chaque révolution du moteur.

Pour calculer les pas/mm pour un axe de votre machine, vous devez savoir :

Valeurs par défaut : $100=250, $101=250, $102=250

$110 $111 $112 - [X, Y, Z] Déplacement maximal possible (mm/mn).

Définit la vitesse maximale de déplacement de chaque axe.

Si un déplacement est prévu à une vitesse supérieure, GRBL ralentie le déplacement pour qu’il ne dépasse pas la vitesse maximale.

Chaque axe a sa propre vitesse indépendante, ce qui est extrêmement utile pour limiter l’axe Z généralement plus lent.

Pour déterminer la valeur de chaque axe, il faut les tester un par un en augmentant petit à petit le paramètre et en lançant un déplacement a chaque fois. Lorsque vous aurez atteint la vitesse maximale que peut accepter votre moteur, celui-ci calera, réduisez la vitesse de 10 a 20%.

Valeurs par défaut : $110=500, $111=500, $112=500 

$120 $121 $122 - [X, Y, Z] Taux d'accélération (mm/mn)

Définit les paramètres d’accélération des axes en millimètres par seconde.

Une valeur inférieure ralentit la mise en mouvement, alors qu’une valeur plus élevée produit des mouvements plus serrés et permet d’atteindre les vitesses d’avance souhaitées beaucoup plus rapidement.

Tout comme le réglage de la vitesse maximale, chaque axe a sa propre valeur d’accélération et est indépendant. Cela signifie que lors d’un mouvement multiaxe l’ensemble accélérera a vitesse la plus basse renseignée pour ces axes.

Pour déterminer la valeur de chaque axe, il faut les tester un par un en augmentant petit à petit le paramètre et en lançant un déplacement a chaque fois. Lorsque vous aurez atteint la vitesse maximale que peut accepter votre moteur, celui-ci calera, réduisez la vitesse de 10 a 20%.

Valeurs par défaut : $120=10, $121=10, $122=10

$130 $131 $132 - [X, Y, Z] Déplacement maximum (mm)

Définit le déplacement maximum d’un bout à l’autre pour chaque axe en mm.

N’est utile que si vous avez activé des soft limits et le homing.

Valeurs par défaut : $130=200, $131=200, $132=200 

Autres commandes '$' de GRBL

Les autres commandes $ fournissent des contrôles supplémentaires pour l’utilisateur, tels que l’impression de commentaires sur l’état modal actuel de l’analyseur de code G ou l’exécution du cycle de ralliement. Cette section explique ce que sont ces commandes et comment les utiliser.

$# - Afficher les paramètres GRBL

Les paramètres du code G stockent les valeurs de décalage des coordonnées f ou les coordonnéesde travail G54-G59, les positions prédéfinies G28/G30, le décalage des coordonnées G92, les décalages de longueur d’outil et le sondage (pas officiellement, mais nous avons quand même ajouté ici). La plupart de ces paramètres sont directement écrits dans l’EEPROM chaque fois qu’ils sont modifiés et sont persistants. Cela signifie qu’ils resteront les mêmes, quelle que soit la mise hors tension, jusqu’à ce qu’ils soient explicitement modifiés. Les paramètres non persistants, qui ne seront pas conservés lors de la réinitialisation ou du cycle d’alimentation, sont les décalages de longueur d’outil G92, G43.1 et les données de sondage G38.2.

Les coordonnées de travail G54-G59 peuvent être modifiées via la commande G10 L2 Px ou G10 L20 Px définie par la norme GRBL NIST et la norme EMC2 (linuxcnc.org). Les positions prédéfinies G28/G30 peuvent être modifiées via les commandes G28.1 et G30.1, respectivement.

Lorsquen $# est appelé, GRBL répondra avec les décalages stockés des coordonnées de la machine pour chaque système comme suit. TLO indique le décalage de longueur de l’outil et PRB indique les coordonnées du dernier cycle de palpage.

$G - Afficher l’état de l’analyseur GRBL

Cette commande imprime tous les modes GRBL actifs dans l’analyseur de code G de GRBL. Lors de l’envoi de cette commande à GRBL, il répondra avec quelque chose comme :

  [G0 G54 G17 G21 G90 G94 M0 M5 M9 T0 S0.0 F500.0]

Ces modes actifs déterminent comment le prochain bloc ou commande G-code sera interprété par l’analyseur G-code de GRBL. Pour ceux qui débutent dans le G-code et l’usinage CNC, les modes placent l’analyseur dans un état particulier, afin que vous n’ayez pas à constamment dire à l’analyseur comment l’analyser. Ces modes sont organisés en ensembles appelés « groupes modaux » qui ne peuventpas être logiquement actifs en même temps. Par exemple, le groupe modal d’unités définit si votre programme de code G est interprété en pouces ou en millimètres.

Une courte liste des groupes modaux, pris en charge par GRBL, est présentée ci-dessous, mais des descriptions plus complètes et détaillées peuvent être trouvées sur le site Web de LinuxCNC. Les commandes G-code en gras indiquent les modes par défaut lors de la mise sous tension ou de la réinitialisation de GRBL.

En plus des modes d’analyseur de code G, GRBL signalera le numéro d’outil T actif, la vitesse de broche S et le taux d’avance F, qui sont tous par défaut à 0 lors d’une réinitialisation. Pour ceux qui sont curieux, ceux-ci ne rentrent pas tout à fait dans de beaux groupes modaux, mais sont tout aussi importants pour déterminer l’état de l’analyseur.

$I - Afficher les informations de build

Cela imprime les commentaires à l’utilisateur la version GRBL et donc la date de construction du code urce. En option, $I pouvez également stocker une chaîne courte pour aider à identifier la machine CNC avec laquelle vous communiquez, si vous avez plus d’une machine utilisant GRBL. Pour définir cette chaîne, envoyez GRBL $I=xxx, où xxx est votre chaîne de personnalisation inférieure à 80 caractères. La prochaine fois que vous interrogerez GRBL avec une $I afficher les informations de build, GRBL imprimera cette chaîne après la version et la date de build.

$N - Afficher les blocs de démarrage

$Nx sont les blocs de démarrage que GRBL exécute chaque fois que vous allumez GRBL ou réinitialisez GRBL. En d’autres termes, un bloc de démarrage est une ligne de G-code que vous pouvez faire exécuter automatiquement par magie par GRBL pour définir vos valeurs modales G-code par défaut, ou tout ce que vous avez besoin que GRBL fasse chaque fois que vous démarrez votre machine. GRBL peut stocker deux blocs de G-code en tant que système default.

Ainsi, lorsque vous êtes connecté à GRBL, tapez $N, puis entrez. GRBL devrait répondre avec quelque chose de court comme :

Pas grand-chose à faire, mais cela signifie simplement qu’il n’y a pas de bloc de code G stocké dans la ligne $N 0 pour que GRBL s’exécute au démarrage. $N 1 est la prochaine line à être exécutée. 

$Nx=line - Enregistrer le bloc de démarrage

IMPORTANT : Soyez très prudent lorsque vous stockez des commandes de mouvement (G0 / 1, G2 / 3, G28 / 30) dans les blocs de démarrage. Ces commandes de mouvement s’exécuteront chaque fois que vous réinitialisez ou allumez GRBL, donc si vous avez une situation d’urgence et que vous devez vous arrêter et réinitialiser électroniquement, un déplacement de bloc de démarrage peut et aggravera probablement les choses rapidement. En outre, ne placez pas de commandes qui enregistrent des données dans EEPROM, telles que G10/G28.1/G30.1. Cela obligera GRBL à réécrire constamment ces données à chaque démarrage être réinitialisation, ce qui finira par user l’EEPROM de votre Arduino.

L’utilisation typique d’un bloc de démarrage consiste simplement à définir vos états modaux préférés, tels que le mode G20 pouces, toujours par défaut à un système de coordonnées de travail différent, ou à fournir un moyen pour un utilisateur d’exécuter une fonctionnalité unique écrite par l’utilisateur dont il a besoin pour son projet fou.

Pour définir un bloc de démarrage, tapez $N 0= suivi d’un bloc de code G valide et d’une entrée. GRBL exécutera le bloc pour vérifier s’il est valide, puis répondra avec un ok ou une erreur : pour vous dire si c’est réussi ou si quelque chose s’est mal passé. S’il y a une erreur, GRBL ne l’enregistrera pas.

Par exemple, supposons que vous souhaitiez utiliser votre premier bloc de démarrage $N 0 pour définir vos modes d’analyseur de code G tels que les coordonnées de travail G54, le mode G20 pouces, le plan G17 XY. Vous alleztaper $N 0=G20 G54 G17 avec une entrée et vous devriez voir une réponse 'ok'. Vous pouvez ensuite vérifier s’il a été stocké en tapant $N et vous devriez maintenant voir une réponse comme $N 0 = G20G54G17.

Une fois que vous avez un bloc de démarrage stocké dans l’EEPROM de GRBL, chaque fois que vous démarrez ou réinitialisez, vous verrez votre bloc de démarrage imprimé et une réponse de GRBL pour indiquer s’il a fonctionné correctement. Donc, pour l’exemple précédent, vous verrez :

Si vous avez plusieurs blocs de démarrage G-code, ils vous seront imprimés dans l’ordre à chaque démarrage. Et si vous souhaitez effacer l’un des blocs de démarrage (par exemple, le bloc 0), tapez $N 0= sans rien suivre du signe égal.

En outre, si vous avez activé le homing, les blocs de démarrage s’exécuteront immédiatement après le cycle de retournement, et non au démarrage. 

$C - Vérifier le mode GRBL

Cela bascule l’analyseur GRBL de GRBL pour prendre tous les blocs entrants les traiter complètement, comme il le ferait en fonctionnement normal, mais il ne déplace aucun des axes, ignore les paliers et éteint la broche et le coolant. Ceci est conçu comme un moyen de fournir à l’utilisateur un moyen de vérifier comment son nouveau programme G-code se comporte avec l’analyseur de GRBL et de surveiller les erreurs (et vérifie les violations de limite souple, si activé).

Lorsque cette option est désactivée, GRBL effectue une réinitialisation logicielle automatique (^X). Ceci a deux objectifs. Cela simplifie un peu la gestion du code. Mais, cela empêche également les utilisateurs de commencer une tâche lorsque leurs modes de code G ne sont pas ce qu’ils pensent être. Une réinitialisation du système donne toujours à l’utilisateur un nouveau départ cohérent.

$X - Tuer le verrouillage d’alarme

Le mode d’alarme de GRBL est un état où quelque chose a mal tourné, comme une limite stricte ou un abandon pendant un cycle, ou si GRBL ne connaît pas sa position. Par défaut, si vous avez activé le homing et allumé l’Arduino, GRBL passe à l’état d’alarme, car il ne connaît pas sa position. Le mode alarme verrouillera toutes les commandes du code G jusqu’à ce que le cycle de guidage « $H » ait été effectué. Ou si un utilisateur doit passer outre le verrou d’alarme pour déplacer ses axes hors de ses interrupteurs de fin de course, par exemple, le verrouillage d’alarme '$X' kill remplacera les verrous et permettra aux fonctions de code G de fonctionner à nouveau.

Mais, marchez prudemment !! Cela ne devrait être utilisé que dans les situations d’urgence. La position a probablement été perdue et GRBL n’est peut-être pas là où vous pensez qu’elle est. Il est donc conseillé d’utiliser le mode incrémental G91 pour effectuer de courts mouvements. Ensuite, effectuez un cycle de guidage ou réinitialisez immédiatement après. 

$H - Cycle de guidage

Cette commande est le seul moyen d’effectuer le cycle de guidage dans GRBL. Certains autres contrôleurs de mouvement désignent une virgule spéciale de code G pour exécuter un cycle de guidage, mais cela est incorrect selon les normes de code G. Homing est une commande complètement distincte gérée par le contrôleur.

CONSEIL : Après avoir exécuté un cycle de guidage, faites plutôt du jogging manuel tout le temps jusqu’à une position au milieu duvolume de votre espace de travail. Vous pouvez définir une position prédéfinie G28 ou G30 comme position post-homing, plus proche de l’endroit où vous allez usiner. Pour les régler, vous devez d’abord placer votre machine à l’endroit où vous souhaitez qu’elle se déplace après le retour. Tapez G28.1 (ou G30.1) pour que GRBL stocke cette position. Donc, après le homing « $H », vous pouvez simplement entrer « G28 » (ou « G30 ») et il s’y déplacera automatiquement. En général, je déplacerais simplement l’axe XY vers le centre et laisserais l’axe Z vers le haut. Cela garantit qu’il n’y a aucune chance que l’outil dans la broche interfère et qu’il ne s’accroche à rien.

$RST=$, $RST=# et $RST=*

Ces commandes ne sont pas répertoriées dans le message d’aide principal de GRBL $, mais sont disponibles pour permettre aux utilisateurs de restaurer tout ou partie des données EEPROM de GRBL. Remarque : GRBL se réinitialisera automatiquement après avoir exécuté l’une de ces commandes pour s’assurer que le système est correctement initialisé.

Commandes en temps réel :

Les quatre dernières commandes de GRBL sont des commandes en temps réel. Cela signifie qu’ils peuvent être envoyés à n’importe quelendroit, n’importe où, et GRBL répondra immédiatement, peu importe ce qu’il fait. Pour ceux qui sont curieux, ce sont des caractères spéciaux qui sont « retirés » du flux série entrant et qui diront à GRBL de les exécuter, généralement en quelques millisecondes.

~ - Début du cycle

Il s’agit de la commande de démarrage ou de reprise du cycle qui peut être émise à tout moment, car il s’agit d’une commande en temps réel. Lorsque GRBL a des mouvements en file d’attente dans sa mémoire tampon et est prêt à partir, la commande ~ cycle start commence à exécuter le tampon et GRBL commence à déplacer les axes. Toutefois, par défaut, le démarrage du cycle automatique est activé, de sorte que les nouveaux utilisateurs n’auront pas besoin de cette commande à moins qu’une suspension du flux ne soit effectuée. Lorsqu’une attente de flux est exécutée, le démarrage du cycle reprend le programme. Le démarrage du cycle ne sera efficace que lorsque des mouvements dans le tampon seront prêts à fonctionner et ne fonctionnera avec aucun autre processus comme le homing.

! - Maintien de l’alimentation

La commande de maintien de l’alimentation arrêtera le cycle actif via une décélération contrôlée, afin de ne pas perdre de position. Il est également en temps réel etpeut être activé à tout moment. Une fois terminé ou suspendu, GRBL attendra qu’une commande de démarrage de cycle soit émise pour reprendre le programme. La retenue de l’alimentation ne peut que mettre en pause un cycle et n’affectera pas le homing ou tout autre processus.

Si vous devez arrêter un cycle en cours de programme et que vous ne pouvez pas vous permettre de perdre votre position, effectuez une retenue d’alimentation pour que GRBL amène tout à un arrêt contrôlé. Une fois terminé, vous pouvez alors émettre une réinitialisation. Essayez toujours d’exécuter une attente d’alimentation chaque fois que la machine est en cours d’exécution avant d’appuyer sur la réinitialisation, sauf bien sûr s’il y a une situation d’urgence.

 

? - Situation actuelle

Le ? renvoie immédiatement l’état actif de GRBL et la position actuelle en temps réel, à la fois en coordonnées machine et en coordonnées de travail. En option, vous pouvez également demander à GRBL de répondre avec le tampon série R X et l’utilisation du tampon du planificateur via le paramètre de masque de rapport d’état. Le ? peut être envoyée à tout moment et fonctionne de manière asynchrone avec tous les autres processus effectués par GRBL. Le paramètre $13 GRBL détermine s’il indique des millimètres ou des pouces. Quand ? est pressé, GRBL répondra immédiatement avec quelque chose comme ceci :

<Inactif,MPos:5.529,0.560,7.000, WPos:1.529,-5.440,-0.000>


Les états actifs dans lesquels GRBL peut être sont les suivants : Idle, Run, Hold, Door, Home, Alarm, Check.

Ctrl-x - Réinitialiser GRBL

Il s’agit de la commande de réinitialisation logicielle de GRBL. C’est en temps réel et peut être envoyé à tout moment. Comme son nom l’indique, il réinitialise GRBL, mais de manière contrôlée, conserve la position de votre machine, et tout se fait sans éteindre votre Arduino. Les seules fois où une réinitialisation logicielle pourrait perdre sa position, c’est lorsque des problèmes surviennent et que les steppers sont tués pendant qu’ils se déplacent. Si c’est le cas, il signalera si le suivi de la position de la machine par GRBL a été perdu. En effet, une décélération incontrôlée peut entraîner des pas perdus, et GRBL n’a aucun retour sur la quantité de pas perdus (c’est le problème avec les steppers en général). Sinon, GRBL se contentera de se réinitialiser, d’exécuter les lignes de démarrage et de continuer son joyeux chemin.

Veuillez noter qu’il est recommandé de faire une réinitialisation logicielle avant de commencer un travail. Cela garantit qu’il n’y a pas de modes de code G actifs qui jouent ou configurent votre machine avant d’exécuter le travail. Ainsi, votre machine démarrera toujours à zéro et régulièrement, et votre machine fera ce que vous attendez.

Dans la catégorie : Gravure - 3D (tutoriaux)