Arduino CNC : Pas à pas de réalisation avec la carte Protoneer

Introduction

L’objectif de ce document est de réaliser le prototype d’une machine à commande numérique sur 3 axes (X,Y,Z) avec la carte Arduino Uno conjugué à la carte Protoneer CNC Shield. 

Ce document présentera succinctement les couches successives qui permettent de passer d’un dessin afficher à l’écran de son ordinateur à une machine permettant de graver ce même dessin sur du bois par exemple.

A la fin nous aurons les bases de compréhension pour la réalisation de différentes machines aux utilisations aussi diverses que l’usinage par enlèvement de matière (Fraisage), l’usinage par dépôt de matière (Impression 3D), la découpe (Laser, jet d’eau…).

Sommaire

Présentation des éléments principaux

– La carte Arduino

– Le shield Protoneer

– Le G-Code

– GRBL

– Universal G-Code Sender

– Inkscape et Code Tools

Lexique

CNC: Computer Numerical Control -> Commande Numérique par Ordinateur

IDE: Integrated Development Environment -> Environnement de Développement

UGS: Universal G-Code Sender

Liste des composants

  • 1 carte Arduino: 20€
  • 1 shield Protoneer: 20€
  • 3 drivers A4988: 18€
  • 3 moteur pas à pas Nema17: 51€
  • IDE Arduino: Gratuit
  • GRBL: Gratuit
  • Universal G-Code Sender: Gratuit
  • Inkscape: Gratuit
  • Gcode Tools: Gratuit
  • Le prix du cadre et des accessoires (Support moteur, câbles …) est variable selon les besoins de votre machine. En effet, si la machine que vous concevez à besoin d’une grande robustesse ou d’une grande précision les matériaux employés seront plus chers.

La carte Arduino

La carte Arduino est principalement composée d’un microcontrôleur Atmega328p qui permet d’analyser et produire des signaux électriques. Il est habituellement utilisé dans l’informatique embarquée industrielle et s’est ensuite imposé dans le grand public grâce à son faible coût et sa relative facilité de programmation permise par son environnement de développement (IDE) homonyme Arduino 1.8.5. 

La carte Arduino est munie de plusieurs « Attaches » communément appelé PIN.

Celles ci peuvent recevoir des signaux électriques de type analogique (Continu) ou digital (Discret, 0ou 1).

Le langage de programmation communément utilisé sur ce type de carte est le C. C’est un langage impératif (Séquentiel) de bas niveaux permettant des instructions simples (for, if …) mais plus élaboré que le langage assembleur (mov 0x0F, %eax) et plus abstrait que le langage Machine ( 0111 0010).

Installation de l’IDE et de la carte Arduino

L’IDE Arduino est disponible ici: https://www.arduino.cc/en/Main/Software 

Une fois téléchargé il suffit de lancer l’exécutable d’installation et de bien sélectionner tous les composants nécessaires à l’utilisation future du logiciel.

Branchez votre carte Arduino dans n’importe quel port USB de votre machine Windows, 

puis déterminez le port COM assigné de votre Arduino.

Pour déterminer le port COM de votre Arduino:

Cliquez sur « Démarrer » -> Clic droit sur « Ordinateur » -> Sélectionnez « Gérer »

Sélectionnez « Gestionnaire de périphériques » dans le volet de gauche

Dans l’arborescence, développez « Ports (COM & LPT) »

Votre Arduino sera sur le port série USB (COMX), où le « X » représente le numéro COM,

par exemple COM6.

 

S’il y a plusieurs ports série USB, faites un clic droit sur chacun d’eux et vérifiez le fabricant, l’Arduino sera « FTDI ».

Plus d’informations sur Arduino ici: https://fr.wikipedia.org/wiki/Arduino

Les cartes Arduino sont disponibles ici: https://store.arduino.cc/arduino-uno-rev3

Le G-Code

Le G-Code est un autre langage de programmation capable de contrôler ce que l’on nommera des actionneurs. Ces actionneurs peuvent être des vérins pneumatiques, des vannes mais dans notre cas il s’agira plus communément de moteurs électriques. Une suite d’instruction en G-Code permettra donc à la machine de réaliser des mouvements dans l’espace en 3 dimensions dans un repère Cartésien X-Y-Z classique.

Pour fixer les idées voici un exemple de programme simple qui permet de comprendre la structure et le fonctionnement d’un programme en G-Code. Les débuts de ligne en Nxx signifient le numéro de ligne du programme.

N10 G21 (Fixation de l’unité de mesure en millimètres)

N20 G00 X0.000 Y0.000 Z10.000 (Déplacement en vitesse rapide au point de coordonnées 0-0-10)

N30 F40 (Fixation de la vitesse de travail par défaut = 40 mm/min)

N40 G01 X24.000 Y18.000 Z10.000 (Déplacement en vitesse travail au point de coordonnées 18-18-10)

N50 G02 X24.000 Y6.000 I18.000 J18.000 (Interpolation circulaire, un quart de cercle, dans le sens horaire vers le point X24,000-Y6 autour du point de rotation de coordonnées absolues I=18 et j=18 )

N60 G91 X2.000 Y0.000 Z0.000 (Déplacement en coordonnées relatives de 2mm sur l’axe des X, X = 26.000 en coordonnées absolues)

N70 G01 X26.000 Y6.000 Z10.000 ( Remontée au point Z= 12mm) 

N80 G28 (Retour au point d’origine X0-Y0-Z0 equivalent a G00 X0 Y0 Z0)

Il existe une longue liste d’instructions en G-Code adaptée aux machine-outils industrielles permettant de déclencher l’ouverture des portes, le changement d’outils, le déclenchement de l’arrosage, la correction de l’usure d’un outillage ou encore la réalisation de sous-programme.

Plus d’information sur le G-Code ici:  https://fr.wikipedia.org/wiki/Programmation_de_commande_numérique

GRBL

C’est le logiciel installé sur la carte Arduino qui fera l’interface entre les instructions en G-Code envoyées à la machine et le pilotage des moteurs pas à pas en fonctions de ces instructions. Pour dire simplement, GRBL est le centre de contrôle pilotant avec précision le mouvement des moteurs pas à pas de la machine en envoyant à haute fréquence un flot continu de pulsions électriques en faisant de petits incréments qui effectivement déplacent l’outil.

GRBL contient quelques touches de raccourci avec lesquels il convient de se familiariser.

– Ctrl + X Redémarrer Grbl

– !Pause

– $Aide

– ? Position actuelle / statut

– $$ Paramètres actuels

– $x = val  ‘x’ étant l’axe à modifier et ‘val’ la nouvelle valeur.

– $H Cycle de retour à X, Y, Z = O.O

Mais avant qu’une machine CNC puisse être utilisée, elle doit être étalonnée.

L’étalonnage est effectué en comparant l’entrée (Capteurs) à la sortie (Actionneurs)

produite par la machine. Pour le calibrer, nous définirons le nombre de pas

nécessaires que le moteur doit faire pour une distance définie. Généralement en pas par

millimètre (pas / mm).

Grbl stocke ces paramètres comme suit:

– $0 – Nombre de pas pour l’axe X / mm

– $1 – Nombre de pas pour l’axe Y / mm

– $2 – Nombre de pas pour l’axe Z / mm

– $8 – Accélération en mm/s2

– …

Les moteurs pas à pas sont conçus avec différents taux de pas (0.2, 0.4, 0.6 …). En

d’autres termes, le moteur doit réaliser plusieurs pas pour faire un tour complet, celui-ci

étant généralement relié à une vis sans fin qui possède elle-même un pas de vis. Si le

pas de vis est de 1 alors le moteur devra faire un tour complet pour avancer de 1 mm.

Installation et configuration de GRBL

– Pour téléverser GRBL sur la carte Arduino, télécharger GRBL à cette adresse: https://github.com/grbl/grbl

– Décompressez et ouvrez le fichier grbl-master.

– Copiez le dossier grbl dans le dossier où sont stockés les exemples Arduino.

Typiquement dans Users/Documents/Arduino/Libraries.

– Redémarrez l’IDE Arduino.

– Aller dans le menu « Fichier », puis en déroulant « Exemple » vous devriez trouver la

librairie « grbl » -> « grblUpload ».

– Une nouvelle fenêtre s’ouvre et une ligne contenant l’instruction importante apparaît:

#include <grbl.h>. C’est cette instruction qui permettra de charger tous les éléments

nécessaire dans la carte Arduino.

Il y a deux méthodes pour configurer GRBL

– Avant de téléverser GRBL sur votre carte Arduino, il peut être utile d’analyser le

fichier de configuration «config.h » situé dans le répertoire Arduino/GRBL et de l’adapter

au besoin spécifique de votre machine.

Si vous liez en parallèle les 2 interrupteurs de fin de course pour un même axe il vous

faudra décommenter la ligne: 

#define LIMITS_TWO_SWITCHES_ON_AXES

Si vous utilisez vos interrupteurs de fin de course en « normalement fermé » il vous

faudra décommenter la ligne: 

#define INVERT_ALL_CONTROL_PINS.

Par défaut GRBL utilise des interrupteurs « normalement ouvert ».

Si vous utilisez un outil rotatif avec un vitesse de broche variable il vous faudra

décommenter les lignes: 

#define VARIABLE_SPINDLE

#define SPINDLE_MAX_RPM 18000.0

#define SPINDLE_MIN_RPM 0.0

Après avoir téléverser GRBL sur votre carte Arduino, nous devons configurer les

moteurs, vitesses, dimensions, courses, capteurs pour chaque axe. 

Une fois la carte Arduino branchée et que l’ordinateur est en liaison série avec lui, lancer le « Moniteur série » depuis le menu « Outils ». Sélectionnez une vitesse de transmission à « 115200 bauds ». 

Vous devriez voir apparaître la ligne « Grbl 1.x [‘$’ for help] ».

Pour lister l’ensemble des paramètres qui vous permettront d’adapter Grbl aux spécificités

de votre machine, il vous suffit de taper $$. GRBL va répondre en renvoyant la liste des

différentes variables configurables.

Nous allons passer en revue les variables les plus importantes à la configuration de notre

machine.

$100, $101, $102: nombre de pas par millimètre définissent le nombre de pas (des moteurs

pas à pas) nécessaires pour parcourir une distance de 1 millimètre sur l’axe indiqué. La

plupart du temps, 100 et 101 (X et Y) seront identiques, alors que Z (102) aura une valeur

différente. 

Un calculateur en ligne sur le site Prusaprinter est disponible ici: https://www.prusaprinters.org/calculator/

$130, $131, $132: Distance maximum à parcourir sur chacun des axes.

Il s’agit de la longueur maximale de déplacement sur cet axe. En théorie si ces distances

sont correctes, les détecteurs de fin de course peuvent devenir inutiles.

$110, $111, $112: Vitesse maximum sur X, Y et Z.

Il s’agit de la vitesse maximale que peuvent tolérer les axes lorsqu’ils sont hors travail donc hors dépôt de matière, hors coupe ou gravure. La vitesse se trouve de manière

expérimentale en fonction des capacités de la machine que vous avez construite.

Il n’est normalement pas nécessaire de toucher aux autres paramètres.

Une liste non exhaustive disponible en Annexe A recense les principaux paramètres de

GRBL ainsi que l’utilisation des commandes ‘$’

Plus d’information sur GRBL ici: https://github.com/grbl/grbl

et ici: https://github.com/grbl/grbl/wiki/Configuring-Grbl-v0.9

Shield Protoneer

 

Dans l’écosystème des cartes Arduino il existe des adaptateurs que l’on nomme des shield, bouclier en français, qui facilitent l’ajout de fonctionnalité au microcontrôleur comme une interface Ethernet,du Wifi ou un écran. Le shield Protoneer quant à lui permet d’ajouter simplement des cartes de pilotage des moteurs pas à pas que l’on appelle Driver. En effet, ce shield simplifie les opérations de câblages des drivers, moteurs (1 pour chaque axe) et capteurs avec la carte Arduino.

Ce shield a plusieurs avantages, notamment:

– Un fusible ré-armable pour protéger les cartes moteurs

– Un connecteur à vis pour brancher l’alimentation 12 à 36V

– 4 contrôleurs de moteur pas à pas. Le 4e contrôleur peut être utilisé pour cloner les signaux d’un axe donné (X, Y ou Z au choix par jumper). C’est très pratique pour piloter une machine qui dispose de 2 moteurs sur un même axe comme rencontré couramment sur l’axe Z.

– Supporte des drivers jusqu’au DRV8825, qui supportent le 32e de pas. 

– Support de 3 interrupteurs de détection de fin de course permettant de câbler un limit+ et un limit – sur chaque axe.

– Support de la commande de broche (M/A) et de son sens (CW/CCW)

– Support d’une commande de pompe d’arrosage (coolant)

– Support pour 3 boutons externes : « Pause/Hold », « Resume/Run » et « Stop »

– Support pour un poussoir d’arrêt d’urgence, câblé sur le Reset de l’Arduino

ATTENTION: Le shield Protoneer ne peut être  solidarisé ou désolidarisé de la carte Arduino uniquement lorsque tout est HORS TENSION.  Auquel cas, cela pourrait causer des dommages irréversibles aussi bien sur la carte Arduino que sur le shields Protoneer ainsi que sur les drivers A4988.

Il est à noter également que le petit potentiomètre se trouvant sur le driver doit se trouver du côté où se trouvent les cavaliers et non pas du côté où se trouvent les condensateurs. Le driver ne possède pas de détrompeur. 

 

Universal G-Code Sender

C’est le logiciel qui fera l’interface avec votre ordinateur et qui permettra d’envoyer le G-Code à la carte Arduino qui lui même sera interprété par GRBL.  

UGS facilite l’envoi de G-Code à la machine sans avoir à écrire de ligne de code.

 

UGS se comporte comme si vous étiez devant l’écran de pilotage d’une véritable machine à commande numérique professionnelle.

 

Une fois installé, vous devrez aller dans « Settings » -> « Firmware Setting » et sélectionner « GRBL ». Ainsi le logiciel saura comment piloter la carte Arduino. 

Logiciel Universal G-Code Sender disponible ici: https://github.com/winder/Universal-G-Code-Sender

Inkscape et Gcode Tools

Inkscape est un puissant logiciel de dessin notamment utilisé par les graphistes pour leurs créations d’icônes sur les pages web. Sa particularité est que le dessin est géré de manière vectorielle et permet donc des manipulations et des transformations complexes car le dessin y est enregistré sous forme d’équation de courbe et non pas par des pixels comme les images de type bitmap que l’on peut réaliser avec le logiciel paint de Windows.

 

Inkscape permet d’ouvrir un nombre conséquent de type d’image au format varié comme les fichiers de type PS, DXF, BMP, JPG … et nous permet de les transformer en image vectorielle. C’est cet atout majeur qui sera utilisé par Gcode Tools pour transformer le modèle vectoriel en une suite d’instruction en G-Code interprétable par Universal G-Code Sender.

Gcode Tools est une extension développée pour Inkscape qui permet l’enregistrement de fichier au format G-Code. Après l’avoir téléchargé depuis le site 

http://www.cnc-club.ru/forum/download/file.php?id=389&sid=e41174d91b4ebb5d94b065a7ff216210 

Décompressez le fichier et déposez le dossier Gcode Tools dans le dossier \Program Files\Inkscape\share\extensions\

Création d’un fichier G-Code

– Lancez Inkscape

– Chargez une image dans Inkscape : « Fichier » -> « Ouvrir » et sélectionnez l’image que vous souhaitez transformer

– Sélectionnez l’image (des flèches pour la redimensionner apparaissent).

– Allez dans le menu « Chemin » -> « Vectoriser le bitmap » 

– Une boite de dialogue apparaît, cliquez sur valider (en laissant les options telles quelles).

– Les 2 images (l’originale et l’image vectorielle) sont superposées. Faites alors un « glissé déposé » afin de séparer les 2 images. Vous pouvez zoomer en gros plan pour apprécier la différence entre une image vectorielle et une image bitmap.

– Sélectionner l’image vectorielle précédemment générée.

– Allez dans le menu « Extensions » -> « Gcode Tools V1.x ».

– une boite de dialogue apparaît. Sélectionnez l’onglet « Préférence ».

– Dans le champ « File », saisissez le nom du fichier gcode à générer.

– Cliquez sur « Appliquez » 

– Un fichier comprenant l’extension « .ngc » est généré.

– Ouvrez le fichier et inspectez le G-Code qui s’y trouve.

Pour télécharger Inkscape c’est ici: https://inkscape.org/fr/

Plus d’information sur Inkscape ici: https://fr.wikipedia.org/wiki/Inkscape

Pour d’information sur Gcode Tools c’est ici: http://www.cnc-club.ru/forum/viewtopic.php?t=35

Annexe A

Cette annexe recense la majeure partie des commandes de GRBL. Il s’agit de la plus

récente et la plus détaillée que j’ai pu trouver en français.

$0 – Step pulse, microseconds 

Les drivers de moteurs pas à pas sont conçus pour une certaine durée minimale d’impulsions de pas. Consultez la fiche de données ou tout simplement essayer quelques numéros. Vous voulez que les impulsions les plus courtes soient reconnues de manière fiable. Si les impulsions sont trop longues, vous pourriez rencontrer des erreurs lors de l’exécution à vitesse élevée et des impulsions trop élevées commencent à se chevaucher. Nous recommandons une valeur autour de 10 microsecondes, ce qui est la valeur par défaut. 

$1 – Step idle delay, msec 

Chaque fois que vos moteurs exécutent un mouvement et viennent à un arrêt, Grbl va retarder la désactivation des moteurs par cette valeur ou vous pouvez toujours garder vos axes en fonction (alimentés de manière à maintenir la position) en définissant cette valeur au maximum de 255 millisecondes. Encore une fois, juste pour répéter, vous pouvez garder tous les axes toujours activés en positionnant $1 = 255. 

Le temps idle de verrouillage est le temps que Grbl gardera les moteurs pas à pas verrouillés avant de les désactiver. Selon le système, vous pouvez définir cette valeur à zéro et ainsi désactiver l’action. Sur d’autres, vous devrez peut-être mettre 25-50 millisecondes pour vous assurer que vos axes parviennent à un arrêt complet avant de désactiver. Ceci pour tenir compte des moteurs pas à pas de machines qui ne peuvent pas rester inactives sur de longues périodes. 

Aussi, gardez à l’esprit que certains pilotes de moteur pas à pas ne se souviennent pas à quel micro pas ils se sont arrêtés, alors quand vous réactivez, vous pouvez avoir des pertes de pas. Dans ce cas, il suffit de garder vos moteurs activés par $1 = 255. 

$2 – Step port invert mask:binary 

Ce paramètre inverse le signal d’impulsions de pas. Par défaut, un signal de pas commence à normalement BAS et va vers le niveau HAUT lors d’un événement d’impulsions de pas. Après un temps d’impulsions de pas fixé par $0, la broche se remet à un niveau BAS, jusqu’à l’impulsion du pas suivant. Quand inversé, le comportement de l’impulsion de pas passe de normalement HAUT à BAS et le retour à HAUT. La plupart des utilisateurs n’auront pas besoin de ce paramètre mais cela peut être utile pour certains pilotes de CNC à moteurs pas à pas qui ont des exigences particulières.

Par exemple, un retard artificiel entre la broche de direction et l’impulsion de pas peut être créé en inversant la pin de pas. 

Ce paramètre de masque est une valeur qui stocke les axes à inverser avec des données binaires. Vous n’avez vraiment pas besoin de comprendre complètement comment cela fonctionne. Il vous suffit de saisir la valeur des paramètres pour les axes que vous souhaitez inverser. Par exemple, si vous voulez inverser les axes X et Z, vous enverriez $ = 5 à Grbl et maintenant devriez lire $ = 5 (valeur masque step : 00000101).  

 $3 – Direction port invert mask:binary 

Ce paramètre inverse le signal de direction pour chaque axe. Par défaut, Grbl suppose que les axes se déplacent dans une direction positive lorsque le niveau de pin de direction est BAS et en sens négatif lorsque le niveau de la broche est HAUT. Souvent, les axes ne se déplacent pas de cette façon sur certaines machines. Ce paramètre va inverser le signal de l’axe de direction de ces axes qui se déplacent dans le sens opposé. 

Ce paramètre de masque fonctionne exactement comme le masque de port step et enregistre, par les données binaires quels axes sont à inverser. Pour configurer ce paramètre, il vous suffit d’envoyer la valeur pour les axes que vous souhaitez inverser. Utilisez le tableau ci-dessus. Par exemple, si vous voulez inverser la direction de l’axe Y uniquement, vous devez envoyer $3 = 2 à Grbl et ainsi devriez maintenant lire $3 = 2 (dir masque port invert : 00000010). 

$4 – Step enable invert, bool 

Par défaut, la broche d’activation est HAUT pour désactiver et BAS pour valider. Si votre installation a besoin du contraire, inverser simplement la broche d’activation en tapant $4 = 1. Désactiver avec $4 = 0. (Peut nécessiter redémarrage pour charger le changement). 

$5 – Limit pins invert, bool 

Par défaut, les repères de la course sont normalement
HAUT avec la résistance de pull-up interne de l’Arduino. Quand une limite est atteinte le niveau de la broche est BAS, Grbl interprète cela comme déclenchée. Pour le comportement opposé, juste inverser les repères de la limite en tapant $5 = 1. Désactiver avec $5 = 0. Vous aurez peut- être besoin d’un redémarrage pour charger la modification. NOTE : Si vous inversez les détections de vos limites, vous aurez besoin d’une résistance pull-down externe pour tous les repères de la course pour éviter de surcharger les broches avec le courant et les détruire. 

$6 – Probe pin invert, bool 

Par défaut, la pin probe est maintenue normalement HAUT par la résistance de pull-up interne de l’ Arduino. Lorsque le capteur fourni le niveau BAS à la broche , Grbl interprète cela comme déclenchée. Pour le comportement opposé, juste inverser la broche de la sonde en tapant $6 = 1. Désactiver avec $6 = 0. Vous aurez peut-être besoin d’un redémarrage pour valider le changement. 

NOTE : Si vous inversez le signal de votre tige de palpage, vous aurez besoin d’une résistance pull-down externe câblée sur la broche de la sonde pour éviter la surcharge et éviter des dommages. 

$10 – Status report mask:binary 

Ce paramètre détermine ce que Grbl doit donner en temps réel comme rapport de situation lorsqu’un ‘?’ est envoyé. Par défaut, Grbl renverra son état de marche (ne peut pas être désactivé), la position de la machine et la position de travail (position de la machine avec les décalages de coordonnées et d’autres compensations appliquées). Trois fonctions de rapport supplémentaires sont disponibles et qui sont utiles pour les interfaces ou les utilisateurs qui initialisent leurs machines, qui incluent le tampon série RX, l’utilisation du tampon de bloc de planificateur et les états des pins de limite (BAS ou HAUT, présentés dans l’ordre ZYX). 

 

Pour les définir, utilisez le tableau ci-dessous afin de déterminer quelles sont les données que vous souhaitez que Grbl renvoie. Sélectionnez les types de rapports que vous aimeriez voir dans les rapports de situation et d’ajouter leurs valeurs. Ceci est la valeur que vous utilisez pour envoyer à Grbl. Par exemple, si vous avez besoin des positions de la machine et de travail, ajoutez les valeurs 1 et 2 et envoyer à Grbl $10 = 3 pour le définir ou si vous avez besoin de la position de la machine seule et l’état de la broche de course, ajoutez les valeurs 1 et 16 et envoyer l $10 = 17 à Grbl.  

En général, conservez ces données d’état en temps réel à un minimum car il faut des ressources pour imprimer et
envoyer ces données à grande vitesse.Par exemple, les informations de pins de limite sont généralement nécessaires uniquement lorsque les utilisateurs mettent leur machine en place. Ensuite, il est recommandé de le désactiver car il n’est pas très utile une fois que vous aurez tout compris. 

$11 – Junction deviation, mm 

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 de segments de ligne d’un chemin de programme G- code. Par exemple, si le chemin G-code a un tour de 10 degrés et la machine se déplace à pleine vitesse, ce paramètre permet de déterminer de
combien la machine doit ralentir pour aller en toute sécurité vers le coin sans perdre de pas.

Nos calculs sont un peu compliqués mais en général, des valeurs plus élevées donnent un mouvement plus rapide dans les courbes, tout en augmentant le risque de perdre des pas et le positionnement. Des valeurs inférieures rendent le gestionnaire d’accélération plus prudent et mèneront plus lentement à une courbe. Donc, si vous avez des problèmes là où votre machine essaie de prendre un coin trop vite, diminuer cette valeur pour le faire ralentir en entrée de virage. Si vous voulez que votre machine se déplace plus rapidement à travers les jonctions, augmentez cette valeur pour l’accélérer. Pour les curieux, cliquez ce lien pour lire les propos de l’algorithme de courbes Grbl, qui représente à la fois la vitesse et l’angle de jonction avec une méthode très simple et efficace. 

$12 – Arc tolerance, mm 

G2 / G3 de Grbl rend cercles, arcs et hélices en les subdivisant en petites lignes minuscules, tels que la précision de l’arc tracé ne soit jamais en dessous de cette valeur. Vous n’aurez probablement jamais besoin de modifier ce paramètre, puisque 0.002 mm est bien en dessous de la précision de la plupart des machines CNC. Mais si vous trouvez que vos cercles sont trop bruts ou que le traçage de l’arc s’effectue lentement, modifiez ce paramètre. Des valeurs inférieures donnent une plus grande précision, mais peut conduire à des problèmes de performance en surchargeant Grbl avec trop de lignes minuscules. Alternativement, des valeurs plus élevées travaillent avec une précision inférieure mais peuvent accélérer les performances de l’arc depuis Grbl qui a moins de lignes à traiter.
Pour les curieux, la tolérance de l’arc est définie comme la distance perpendiculaire maximale d’un segment de ligne avec ses points d’extrémité se trouvant sur l’arc, c’est à dire une corde. Avec une géométrie de base, on résout, pour la longueur des segments de ligne à tracer, l’arc qui répond à ce paramètre. La modélisation des arcs est grande de cette manière, parce que les segments d’arc ajustent automatiquement l’échelle de longueur pour assurer les performances de l’arc optimal de traçage, tout en ne perdant jamais de précision. 

$13 – Report inches, bool 

Grbl a une fonctionnalité de rapports de positionnement en temps réel pour fournir une rétroaction à l’utilisateur sur la position exacte de la machine à cet instant, ainsi que, pour coordonner les paramètres de compensation et de sondage. Par défaut, il est mis pour signaler en mm mais en envoyant une commande de $13 = 1, vous envoyez ce flag booléen à true et ces fonctions de reports seront à présent en pouces. $13 = 0 retour en mm. 

$20 – Soft limits, bool 

Soft limits est un dispositif de sécurité pour empêcher votre machine de se mouvoir trop loin et au-delà des limites de déplacement et éviter la casse. Il fonctionne en connaissant les limites maximales de déplacement pour chaque axe et où Grbl est en coordonnées machine. Chaque fois qu’une nouvelle information G-code est envoyée à Grbl, il vérifie si vous avez accidentellement dépassé les limites de la machine. Si vous êtes dans ce cas, Grbl stoppera, y compris l’arrêt de la broche et du liquide de refroidissement, puis règle l’alarme du système indiquant le problème. La position de la machine sera conservée car l’arrêt n’est pas du à un arrêt forcé immédiat comme des limites strictes. 

REMARQUE: Soft limits nécessite que homing soit activé et que les paramètres de déplacement maximaux d’axe soient activés, parce que Grbl a besoin de savoir où il est.
$20 = 1 pour activer et $20 = 0 pour désactiver. 

$21 – Hard limits, bool 

Hard limits fonctionne fondamentalement de la même manière que Soft limits, mais utilise des commutateurs physiques. Fondamentalement, vous câblez quelques interrupteurs (mécaniques, magnétiques ou optiques) près de la fin de course de chaque axe si jamais vous sentez qu’il pourrait y avoir des problèmes si votre programme s’approcherait de trop des limites fixées. Lorsque l’interrupteur s’active, il va immédiatement arrêter tout mouvement, l’arrêt du refroidissement et de la broche (si connecté) et passer en mode d’alarme, ce qui vous oblige à vérifier votre machine et de tout réinitialiser. 

Pour utiliser les Hard limits avec Grbl, les pins de fin de course sont tenus HAUT avec une résistance interne pull-up donc tout ce que vous avez à faire est de brancher un fil dans un commutateur normalement ouvert entre la broche et la masse et mettre Hard limits à $21 = 1. (Désactiver avec $21 = 0).

Nous vous conseillons fortement de prendre les mesures de prévention d’interférences électriques. Si vous voulez une limite pour les deux extrémités de course d’un des axes, il faudra brancher deux interrupteurs en parallèle entre la broche et la masse, si l’un des deux s’enclenche, il déclenche la Hard limits. 

Gardez à l’esprit qu’un événement de limite matérielle est considéré comme un événement critique où les moteurs pas à pas s’arrêtent immédiatement et auront probablement perdus des pas. Grbl n’a pas de commentaires sur la situation, de sorte qu’il ne peut garantir et qu’il n’a aucune idée où il est. Donc, si une Hard limits est déclenchée, Grbl ira dans un mode boucle d’alarme infinie, vous donnant une obligation de vérifier votre machine et vous obligeant à réinitialiser Grbl. Rappelez-vous que c’est une fonction de sécurité. 

$22 – Homing cycle, bool 

Ah! homing. Pour ceux qui sont juste initié à la CNC, le cycle homing est utilisé pour localiser avec exactitude une position connue et cohérente sur une machine, chaque fois que vous démarrez votre Grbl entre les sessions. En d’autres termes, vous savez exactement où vous êtes à tout moment, à chaque fois. Disons que vous commencez l’usinage d’une pièce ou vous êtes sur le point de commencer la prochaine étape et une panne de courant redémarre Grbl et Grbl n’a aucune idée de l’endroit où il se trouve. Vous êtes incapable de déterminer où vous en êtes avec la tâche. Si vous avez un Homing, vous avez toujours le point de référence zéro machine pour localiser tout ce que vous avez à faire à partir de là, de lancer le cycle de homing et de reprendre là où vous vous étiez arrêté. 

Pour mettre en place le cycle de homing pour Grbl, vous devez disposer d’interrupteurs de fin de course fixés solidement pour avoir un point de référence bien précis. Habituellement, ils sont configurés dans le point le plus éloigné de + x, + y, + z de chaque axe. Câbler vos fins de course entre les pins fin de course et la masse, tout comme avec les hard limits, afin de permettre la localisation de Homing. 

Vous pouvez utiliser vos interrupteurs de limite pour les deux hard limits et homing. Ils jouent le même rôle. 

Par défaut, le cycle de homing de Grbl déplace l’axe Z positif en premier pour dégager l’espace de travail, puis déplace à la fois X et Y en même temps dans le sens positif. Pour configurer la façon dont votre cycle de homing se comporte, il y a des réglages Grbl plus en bas de la page décrivant ce qu’ils font (et la compilation des options ) 

Aussi, encore une chose à noter, lorsque homing est activée. Grbl verrouille toutes les commandes G-code jusqu’à ce que vous effectuiez un cycle de homing. Cela signifie qu’aucun mouvement d’axes n’est effectué, à moins que le verrouillage ne soit désactivé ($X) mais plus sur cela plus tard. La plupart, sinon tous les contrôleurs CNC, font quelque chose de semblable car ils ont la plupart du temps un dispositif de sécurité pour empêcher les utilisateurs de faire une erreur de positionnement. C’est tellement vite arrivé et ennuyeux si une partie de la mécanique est détruite. Si vous trouvez des anomalies ou des bugs, s’il vous plaît, faites-nous le savoir et nous allons essayer d’y remédier. 

NOTE : Consultez config.h pour plus d’options de homing pour les utilisateurs avancés. Vous pouvez désactiver le lock- out de homing au démarrage, configurer le déplacement des axes, leur ordre et bien plus encore. 

$23 – Homing dir invert mask, int:binary 

Par défaut, Grbl suppose que vos fins de course de homing sont dans le sens positif, le premier déplacement de l’axe z positif, alors axes XY positif avant d’essayer de localiser précisément le zéro machine en allant d’avant en arrière lentement autour de l’interrupteur. Si votre machine dispose d’un interrupteur de fin de course dans le sens négatif, le masque de direction homing peut inverser la direction des axes. Il fonctionne exactement comme l’inverseur du port de pas et du port de masques, où tout ce que vous avez à faire est d’envoyer la valeur dans le tableau pour indiquer quels axes vous voulez inverser et faire la recherche dans la direction opposée. 

$24 – Homing feed, mm/min 

Le premier cycle de homing recherche les fins de course à une vitesse plus élevée et après les avoir trouvés, se déplace plus lentement pour détecter l’emplacement précis du zéro machine. Homing est plus lent que la vitesse de déplacement. Réglez cette valeur quelconque à un taux qui fournit à la machine la localisation précise du zéro. 

$25 – Homing seek, mm/min 

Homing seek est les mm/min de recherche sur le cycle de prise d’origine ou la vitesse à laquelle il tente d’abord de trouver les fins de course. Réglez ce taux afin d’arriver au fin de course dans un temps assez court mais sans tout casser si c’est trop rapide. 

$26 – Homing debounce, ms 

Chaque fois qu’un interrupteur déclenche, on peut avoir un bruit électrique / mécanique qui fait «rebondir» le signal HAUT et BAS pour quelques millisecondes avant la stabilisation. Pour résoudre ce problème, vous devez éviter les rebonds du signal, soit par le matériel avec une sorte de conditionneur de signal ou de logiciels avec un court délai pour laisser le temps du rebond et d’arriver avec un signal stabilisé. Grbl effectue un délai court, seulement pendant la localisation du zéro machine. Définissez cette valeur de retard pour que, quel que soit votre commutateur, vous obteniez un homing répétable. Dans la plupart des cas, 5-25 millisecondes est très bien. 

$27 – Homing pull-off, mm 

Dans le cas de partage des mêmes fins de course et de homing, les fins de course ne fonctionnent qu’en homing. En d’autres termes, il aide à prévenir le déclenchement accidentel des limites après un cycle de homing. 

$30 – Punch actuator down invert, bool 

$30 = 0 Commandé par : +5 V
$30 = 1 Commandé par : 0 V

$31 – Punch actuator up invert, bool 

$31 = 0 Commandé par : +5 V 
$31 = 1 Commandé par : 0 V

$32 – Punch sensor down invert, bool 

$32 = 0 Si détecté = +5 V
$32 = 1  Si détecté = 0 V

$33 – Punch sensor up invert, bool 

$33 = 0 Si détecté = +5 V 
$33 = 1 Si détecté = 0 V

$100, $101 and $102 – [X,Y,Z] steps/mm 

Grbl a besoin de savoir dans quelle mesure chaque étape placera l’outil dans la réalité. Pour calculer pas/ mm pour un axe de votre machine, vous devez savoir : Les mm parcourus par la rotation de votre moteur pas à pas. Cela dépend de vos engrenages d’entraînement des courroies ou du pas des vis. Les pas complets pour un tour de vos moteurs pas à pas (typiquement 200) Les micropas par pas de votre contrôleur (typiquement 1, 2, 4, 8, ou 16). 

Astuce : L’utilisation de valeurs élevées de micropas (par exemple, 16) peut réduire votre couple de moteur pas à pas, afin d’utiliser le plus bas qui vous donne la résolution de l’axe désiré et propriétés de fonctionnement confortables. Les pas/ mm peuvent alors être calculés comme ceci : 

pas_par_mm = (pas_par_tour * micropas) / mm_par_tour 

Calculer cette valeur pour chaque axe et écrire ces paramètres dans Grbl. 

$110, $111 and $112 – [X,Y,Z] Max rate, mm/min 

Ceci définit le déplacement maximal possible de chaque axe. Chaque fois que Grbl prévoit un déplacement, il vérifie si oui ou non le mouvement provoque un quelconque dépassement de la course max de ces différents axes. Si oui, il va ralentir le mouvement pour vous assurer qu’aucun des axes ne dépasse sa limite de déplacement max. Cela signifie que chaque axe dispose de sa propre vitesse indépendante, ce qui est extrêmement utile pour limiter la vitesse de l’axe Z typiquement plus lente. 

La façon la plus simple pour déterminer ces valeurs est de tester chaque axe l’un après l’autre en augmentant lentement les réglages de déplacement max. Par exemple, pour tester l’axe X, envoyer quelque chose comme G0 X50 à Grbl avec assez de distance de parcours de sorte que l’axe accélère à sa vitesse maximale. Vous saurez que vous avez touché le seuil de taux max lorsque vos moteurs pas à pas décrochent. Ca va faire un peu de bruit, mais ne devrait pas nuire à vos moteurs. Entrez un réglage de 10-20% en dessous de cette valeur, de sorte que vous pouvez tenir compte de l’usure, la friction et la masse de votre pièce / outil. Ensuite, répétez l’opération pour vos autres axes. 

$120, $121, $122 – [X,Y,Z] Accélération, mm/sec^2 

Ceci définit les paramètres d’accélération des axes en mm / seconde / seconde. De manière simpliste, une valeur inférieure soulage et rend Grbl plus lent en mouvement, tandis qu’une valeur plus élevée accélère le mouvement. Tout comme le réglage de la fréquence max, chaque axe dispose de sa propre valeur d’accélération et ils sont indépendants les uns des autres. Cela signifie qu’un mouvement multi-axe ne fera accélérer aussi rapidement que l’axe le plus bas ne peut le faire. 

Encore une fois, comme le réglage de la fréquence max, la façon la plus simple pour déterminer les valeurs de ce paramètre est de tester individuellement chaque axe de plus en plus petites valeurs jusqu’à ce que le moteur cale. Puis finaliser votre paramètre d’accélération avec une valeur de 10- 20% en dessous de cette valeur absolue max. Cela devrait tenir compte de l’usure, la friction et l’inertie de masse. Nous recommandons fortement d’essayer les programmes G-code à blanc avec vos nouveaux paramètres avant de lancer une opération d’usinage. Parfois, le chargement sur votre machine est différent lors du déplacement simultané de plusieurs axes. 

$130, $131, $132 – [X,Y,Z] Max travel, mm 

Ceci définit la course maximale de bout en bout pour chaque axe, en mm. Ceci est utile uniquement si vous avez des limites douces (homing) et permis, comme cela est utilisé uniquement par les fonctions de limite souple de Grbl pour vérifier si vous avez dépassé vos limites de la machine avec une commande de mouvement. 

Les autres commandes ‘$’ de GRBL

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

$# – View gcode parameters
Les paramètres G-code stockent les valeurs de décalage pour les coordonnées G54-G59, G28 / G30 travail positions prédéfinies, G92 décalage de coordonnées, des décalages de longueur d’outil et le palpeur (pas officiellement, mais nous avons l’ajouté ici ). La plupart de ces paramètres sont directement écrit en mémoire EEPROM à chaque fois qu’ils sont modifiés et sont persistants. Ce qui signifie qu’ils resteront les mêmes, indépendamment de la puissance vers le bas, jusqu’à ce qu’ils soient modifiés explicitement. Les paramètres non persistants, qui ne sont pas conservés lorsque réinitialisation ou redémarrage, sont G92, G43.1 longueur outil de compensations et le G38.2 données du palpeur. 

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

Lorsque $# est appelé, Grbl répondra avec les décalages enregistrés à partir des coordonnées machine pour chaque système comme suit. TLO dénote la longueur d’outil, et PRB indique les coordonnées du dernier cycle de palpage.  

$G – View gcode parser state
Cette commande imprime tous les modes de Gcode actifs dans l’analyseur G-Code. Lors de l’envoi de cette commande à Grbl, il répondra avec quelque chose comme :  

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

Une courte liste des groupes modaux, soutenus par Grbl, est illustrée ci-dessous mais des descriptions plus complètes et détaillées peuvent être trouvées sur le site de LinuxCNC. Les commandes G-code en caractère gras indiquent les modes sur la mise sous tension ou la réinitialisation de Grbl.  

En plus des modes de l’analyseur G-code, Grbl rendra compte sur l’outil actif T, S vitesse de broche et le taux d’alimentation F, tout sera à 0 lors de la réinitialisation. Pour info : ceux-ci ne correspondent pas tout à fait aux groupes modaux mais sont tout aussi importants pour déterminer l’état de l’analyseur.

$I – View build info
Ce retour d’impression à l’utilisateur indique la version et la source du code et la date de construction Grbl. Eventuellement, avec $I, on peut également stocker une courte chaîne pour aider à identifier avec quelle machine CNC vous communiquez, si vous avez plusieurs machines pilotées par Grbl. Pour définir cette chaîne, envoyer Grbl $I = xxx, où xxx est votre chaîne de personnalisation qui est inférieure à 80 caractères. La prochaine fois que vous interrogez Grbl avec un $I, Grbl imprimera cette chaîne après la version et la date de construction. 

$N – View startup blocks 

$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 avoir exécuté automatiquement pour configurer votre G- code par défaut modal ou toute autre chose dont vous aurez besoin à chaque fois que vous démarrez votre machine. Grbl peut stocker deux blocs de G code par défaut. 

Donc lorsque vous êtes connecté à Grbl, tapez $N, puis « enter ». Grbl doit répondre avec quelque chose de court, comme :  

 

Pas grand chose à faire, mais cela signifie simplement qu’il n’y a pas de bloc G-code stocké dans la ligne $N0 de Grbl pour une exécution au démarrage. $N1 est la prochaine ligne à exécuter. 

$Nx=line – Save startup block 

IMPORTANT: Soyez très prudent lorsque vous stockez toutes commandes de mouvement (G0 / 1, G2 / 3, G28 / 30) dans les blocs de démarrage. Ces commandes de mouvements se dérouleront chaque fois que vous ré enclenchez Grbl donc si vous avez une situation d’urgence comme l’e-arrêt et reset, un déplacement de bloc de démarrage peut et va probablement aggraver les choses rapidement. Aussi, ne pas placer de commandes qui enregistrent des données sur EEPROM, tels que G10 / G28.1 / G30.1. Cela obligera Grbl à constamment ré- écrire ces données à chaque démarrage et réinitialisation, qui finiront par user l’EEPROM de votre Arduino. 

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

Pour définir un bloc de démarrage, tapez $N0 = suivi d’un bloc G-code valide et une entrée. Grbl déroulera le bloc pour vérifier s’il est valide et répondra ensuite avec un OK ou une erreur : S’il y a une erreur, Grbl ne sauvera pas. 

Par exemple, disons que vous voulez utiliser votre premier bloc de démarrage $N0 à définir vos G codes en mode d’analyseur, comme les coordonnées de travail de G54, G20 en mode pouces. Vous taperez $N0 = G20 G54 G17 avec une entrée et vous devriez voir une réponse ‘OK’. Vous pouvez ensuite vérifier si elles ont été stockées en tapant $N et vous devriez maintenant voir une réponse comme $N0 = G20G54G17. 

Une fois que vous avez un bloc de démarrage de 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 si tout est ok. Donc, pour l’exemple précédent, vous verrez : 

Si vous avez plusieurs blocs de démarrage en G code, ils sont imprimés à nouveau pour chaque démarrage et si vous souhaitez effacer l’un des blocs de démarrage (par exemple, le bloc 0) tapez $N0 = sans aucune annotation après le signe égal.  

Ainsi, si vous avez activé homing, les blocs de démarrage seront exécutés immédiatement après ce cycle de homing et non au démarrage. 

$C – Check gcode mode
Cette bascule gcode permet à l’analyseur de Grbl de prendre tous les blocs entrants et de les traiter complètement, comme il le ferait en fonctionnement normal mais il ne déplace pas les axes, ignore la position et l’alimentation de la broche et du liquide de refroidissement. Ceci est conçu pour fournir à l’utilisateur un moyen de tester ses nouveaux programmes G- code avec l’analyseur de Grbl et de surveiller d’éventuelles erreurs (et contrôle les violations de limites douces, si activées).

Lorsque désactivé, le Grbl effectuera un soft-reset automatique (^ X). Ceci pour deux raisons. Il simplifie un peu la gestion de code mais il empêche également les utilisateurs de démarrer une tâche quand leurs modes G-code ne sont pas ce qu’ils pensent qu’ils sont. Une réinitialisation du système donne toujours un démarrage sain à l’utilisateur. 

$X – Kill alarm lock
Le mode d’alarme de Grbl est un état qui signale un problème critique, comme une fin de course activée ou une interruption pendant un cycle ou si Grbl ne connaît pas sa position. Par défaut, si vous avez un homing d’activé à la mise sous tension de l’Arduino, Grbl passe à l’état d’alarme, car il ne connaît pas sa position. Le mode d’alarme verrouille toutes les commandes G-code jusqu’à ce que le cycle de homing, le ‘$H’ a été effectué ou si un utilisateur a besoin de déplacer les axes sur leurs fins de course, par exemple, le verrouillage de kill alarme ‘$X’ remplace les fins de course et permet aux fonctions G-code de fonctionner à nouveau. 

Mais avancer avec précaution !! Cela ne devrait être utilisé que dans des situations d’urgence. La position a probablement été perdue et Grbl n’est peut-être pas là où vous pensez qu’il soit. Donc, il est conseillé d’utiliser le mode incrémental G91, de faire des déplacements courts. Ensuite, effectuez un cycle de homing ou réinitialiser immédiatement après. 

$H – Run homing cycle
Cette commande est la seule façon pour effectuer le cycle de Homing dans Grbl. Certains autres contrôleurs de mouvements désignent une commande spéciale de G-code et exécutent un cycle de Homing mais cela est inexact selon les normes G-code. Homing est une commande complètement séparée et gérée par le contrôleur. 

CONSEIL : Après l’exécution d’un cycle de Homing,mettez plutôt le jogging manuellement dans une position au milieu de votre espace de travail. Vous pouvez placer un G28 ou G30 pour prédéfinir la position pour être à votre position de post-homing, la plus proche de l’endroit où vous serez en usinage. Pour régler cela, vous devez d’abord vous rappelez où la machine se déplace après le homing. Taper G28.1 (ou G30.1) après avoir stocké cette position dans Grbl. Alors après homing ‘$H’, vous pouvez simplement saisir ‘G28’ (ou ‘G30’) et il va se déplacer automatiquement. En général, je voudrais juste déplacer l’axe XY du centre et ignorer l’axe Z. Cela garantit qu’il n’y a pas d’interférences avec l’outil dans la broche et que rien ne se coïnce. 

$RST=$, $RST=#, and $RST=*- Restore Grbl settings and data to defaults
Ces commandes ne sont pas répertoriées dans les messages d’aide de Grbl$ mais sont disponibles pour permettre aux utilisateurs de restaurer des parties ou l’ensemble des données de l’EEPROM de Grbl. Remarque : Grbl se réinitialise automatiquement après l’exécution de l’une de ces commandes pour assurer que le système soit initialisé correctement. 

  • $RST = $ : Efface et restaure les paramètres Grbl $$ par défaut, qui sont définis par le fichier de paramètres par défaut utilisé lors de la compilation de Grbl. Souvent, les équipementiers vont construire leurs machines avec leurs paramètres recommandés spécifiques. Cela fournit aux utilisateurs et aux équipementiers un moyen rapide d’obtenir un retour à la case départ, si quelque chose a mal tourné ou si un utilisateur veut recommencer.
  • $RST = # : Efface et met à zéro toutes les coordonnées G54-G59 et les coordonnées G28/30 mémorisées dans l’EEPROM. Ce sont généralement les valeurs observées dans les paramètres impression # $. Cela fournit un moyen facile d’effacer sans avoir à le faire manuellement pour chaque ensemble avec une commande G20 L2 / 20 ou G28.1 / 30. 1 
  • $RST = * : Ceci supprime et restaure toutes les données de l’EEPROM utilisés par Grbl. Cela inclut les paramètres $$, $#, les lignes de démarrage $N et la chaîne d’information $I. Notez que cela ne nettoie pas toute l’ EEPROM, seules les zones de données utilisées par Grbl. Pour faire un nettoyage complet, s’il vous plaît utiliser le projet nettoyage de l’EEPROM Arduino. 

Real-Time Commands: ~, !, ?, and Ctrl-X

Les quatre dernières commandes de Grbl sont des commandes en temps réel. Cela signifie qu’elles peuvent être envoyées à tout moment, 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 sélectionnés à partir du flux de série entrant et diront à Grbl de les exécuter, habituellement en quelques 5 millisecondes. 

~ – Cycle start
Ceci est le cycle démarrer ou reprendre la commande qui peut être émis à tout moment car c’est une commande en temps réel. Lorsque Grbl a des mouvements en attente dans sa mémoire tampon et est prêt à fonctionner, la commande ~ début de cycle va commencer l’exécution de la mémoire tampon et Grbl commencera à déplacer les axes. Toutefois, par défaut, l’auto cycle est activé, de nouveaux utilisateurs n’auront pas besoin de cette commande à moins qu’un redémarrage ne soit effectué. Quand un redémarrage est exécuté, le départ cycle reprendra le programme. Le démarrage du cycle ne sera efficace que quand il y a des ordres dans le tampon prêts à s’exécuter et ne fonctionnera pas avec d’autres processus comme homing. 

! – Feed hold
La commande d’alimentation de maintien apportera le cycle actif à un arrêt via une décélération contrôlée, afin de ne pas perdre la position. Elle est également en temps réel et peut être activée à tout moment. Une fois terminé ou suspendu, Grbl attendra une commande de cycle de démarrage pour reprendre le programme. Faire une pause ne peut interrompre qu’un cycle et n’affectera pas homing ou tout autre processus. 

Si vous avez besoin d’arrêter un cycle à mi-programme et ne pas perdre la position, effectuer une prise d’alimentation à Grbl comme pour un arrêt contrôlé. Une fois terminé, vous pouvez effectuer une réinitialisation. Toujours essayer d’exécuter une prise d’alimentation lorsque la machine est en marche avant de faire une réinitialisation, sauf bien sûr s’il y a une situation d’urgence. 

? – Current status
La commande ? retrouve immédiatement l’état actif de Grbl et la position actuelle en temps réel, à la fois dans les coordonnées de la machine et les coordonnées de travail. En option, Grbl pourra aussi répondre en retour avec l’utilisation de la mémoire tampon série RX et planificateur via le réglage de masque de rapport de situation.
La commande ? peut être envoyée à tout moment et fonctionne de manière asynchrone avec tous les autres processus que Grbl fait. Le réglage Grbl $13 détermine les valeurs en millimètres ou en pouces. Quand ? est pressé, Grbl répond immédiatement avec quelque chose comme ce qui suit : 

Les états actifs Grbl peuvent être dans : Idle, Run, Hold, Door, Home, Alarme, Check

Idle : Tous les systèmes sont prêts, aucun déplacement en file d’attente et est prêt à toute commande.

Run : Indique qu’un cycle est en marche. 

Hold : attente d’alimentation en cours d’exécution ou ralentissement pour un arrêt. Après l’arrêt complet, Grbl restera en attente d’un début de cycle pour reprendre le programme.

Door : (Nouveau en v 0.9i) Cette compilation d’options entraîne Grbl pour nourrir attente, l’arrêt de la broche et du liquide de refroidissement et attend que l’interrupteur de la porte a été fermé et l’utilisateur a émis un début de cycle. Utile pour les OEM qui ont besoin de portes de sécurité.

Home : Au milieu d’un cycle de homing. NOTE: Les positions ne sont pas mises à jour en direct pendant le cycle de homing d’origine mais elles vont être mises à la position du point zéro de référence une fois cette action faite.

Alarm : Cela indique que quelque chose a mal tourné ou Grbl ne connaît pas sa position. Cet état verrouille toutes les commandes G-code mais vous permet
d’interagir avec les paramètres de Grbl si vous en avez besoin. ‘$X’ Alarme déverrouille le blocage et met Grbl en état de veille, ce qui vous permettra de poursuivre
votre travail. Comme dit précédemment, se méfier de ce que vous faites après une alarme.

Check : Grbl est en mode contrôle G-code. Il permettra de traiter et répondre à toutes les commandes G-code mais pas le mouvement ou d’allumer quoi que ce soit. Une fois basculée avec une autre commande ‘$C’, Grbl se réinitialisera 

Ctrl-x – Reset Grbl
Cette commande est la réinitialisation logicielle de Grbl. Elle est en temps réel et peut être envoyée à tout moment. Comme son nom l’indique, il réinitialise Grbl mais d’une manière contrôlée, conserve la position de la machine et tout se fait sans éteindre votre Arduino. Les seules fois où un soft-reset pourrait perdre la position est lorsque des problèmes surgissent et des défauts moteurs alors qu’ils se déplaçaient. Si oui, il va rapporter si le suivi de Grbl de position de la machine a été perdu. En effet, une décélération incontrôlée peut conduire à des pas perdus et Grbl ne pourra signaler combien il en a perdu (ce qui est le problème avec les pas à pas en général). 

Sinon, Grbl sera tout simplement ré-initialisé, exécutera les lignes de démarrage et continuera son petit bonhomme de chemin. 

S’il vous plaît notez qu’il est recommandé de faire un soft-reset avant de commencer un travail. Cela garantit qu’il n’y a pas de modes actifs ou la reconfiguration de votre machine avant d’exécuter la tâche G-code. Donc, votre machine partira toujours sur des bases saines et fera ce que vous attendez d’elle. 

 

 

Vincent Pleux – 20 janvier 2018

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *