branchement des fins de course.

Discussion sur et autour de GRBL. Réglages, paramètres, différentes versions, questions, astuces, etc...
diiity
Pied Tendre Actif
Messages : 18
Enregistré le : 04 mai 2020, 18:17

branchement des fins de course.

Message non lu par diiity » 29 mai 2020, 12:28

Bonjour,

J'utilise arduino uno et le shield V3 , GRBL 1.1H avec CNCjs

Dans GRBL j'ai bien spécifié $5=1 pour valider les fin de course NC(fermé) et $21=1 pour l'activation des fins de course.

Sur le shield V3, que je branche sur Z Y et X en entrée - ou en entrée +, ça ne fonctionne pas et j'ai ce message d'erreur:

CNCjs 1.9.22 [Grbl]
Connected to COM35 with a baud rate of 115200
Grbl 1.1h ['$' for help]
client> $$
[MSG:Check Limits]
[MSG:'$H'|'$X' to unlock]
ALARM:1 (Hard limit)
[MSG:Reset to continue]
>

Qu'en pensez vous?

diiity
Avatar du membre
DranerB
Administrateur
Messages : 2079
Enregistré le : 31 janv. 2019, 11:56
Localisation : Bourbon-Lancy, France
A remercié : 109 fois
A été remercié : 215 fois
Contact :

Re: branchement des fins de course.

Message non lu par DranerB » 29 mai 2020, 13:25

diiity a écrit :
29 mai 2020, 12:28
Bonjour,

J'utilise arduino uno et le shield V3 , GRBL 1.1H avec CNCjs

Dans GRBL j'ai bien spécifié $5=1 pour valider les fin de course NC(fermé) et $21=1 pour l'activation des fins de course.

Sur le shield V3, que je branche sur Z Y et X en entrée - ou en entrée +, ça ne fonctionne pas et j'ai ce message d'erreur:

CNCjs 1.9.22 [Grbl]
Connected to COM35 with a baud rate of 115200
Grbl 1.1h ['$' for help]
client> $$
[MSG:Check Limits]
[MSG:'$H'|'$X' to unlock]
ALARM:1 (Hard limit)
[MSG:Reset to continue]
>

Qu'en pensez vous?

diiity
Ben, à première vue, tes fins de course sont vues comme actives avant de faire quoi que ce soit. Donc je repasserais à $5=0.

Personnellement, je n'utilise jamais, avec GRBL, ces "hard limits", parce qu'elles déclenchent une erreur, comme tu as pu le voir. Je ne mets que les switches nécessaires à un homing, et utilise les "soft limits". Les limites "softs" ont pour conséquence que, si GRBL détermine que le mouvement demandé dépasse une limite soft, le mouvement n'est tout simplement pas exécuté. Mais ça ne génère pas d'erreur bloquante.

Bien sûr, ceci n'est que mon point de vue, et d'autres manières de faire sont aussi valides. Simplement, elles me semblent plus compliquées à mettre en oeuvre.
Bien Cordialement,
Bernard
Image
diiity
Pied Tendre Actif
Messages : 18
Enregistré le : 04 mai 2020, 18:17

Re: branchement des fins de course.

Message non lu par diiity » 29 mai 2020, 14:08

Mais sur le shield il faut les brancher comment?
Avatar du membre
DranerB
Administrateur
Messages : 2079
Enregistré le : 31 janv. 2019, 11:56
Localisation : Bourbon-Lancy, France
A remercié : 109 fois
A été remercié : 215 fois
Contact :

Re: branchement des fins de course.

Message non lu par DranerB » 29 mai 2020, 18:33

diiity a écrit :
29 mai 2020, 14:08
Mais sur le shield il faut les brancher comment?
Comment, comment? Ce sont des interrupteurs, il n'y a pas de + et de - qui compte. Le NO où NC est déterminé par le branchement sur le switch lui-même, pas sur le shield.
Bien Cordialement,
Bernard
Image
dji54
Apprenti
Messages : 37
Enregistré le : 24 juil. 2019, 17:05
A remercié : 6 fois
A été remercié : 3 fois

Re: branchement des fins de course.

Message non lu par dji54 » 10 juin 2020, 19:34

bonjour diiity,

si tu un cnc shield V3 (comme moi)
les connectique Z+ sont inverser avec SpnEN
tu doit donc bancher le capteur de fin de courses Z+ sur SpnEN.

GRBL est configure par Default sur des fin de courses câblé entre COM et NO
si tu veux câbler tes fins de courses en COM-NC il faudra rentré le réglage $5=1
diiity
Pied Tendre Actif
Messages : 18
Enregistré le : 04 mai 2020, 18:17

Re: branchement des fins de course.

Message non lu par diiity » 10 juin 2020, 19:57

Bonjour,

Oui, tous cela a été fait mais le souci est le même, ça ne fonctionne pas.

J'ai même configuré avec $21=1, $22=1 et $23=2 pour avoir le home, seul le contact des Y fonctionne, un appui sur les contacts Z et X ne bloque pas la machine, et cela en contact ouvert ou fermé.

Par contre, les contacts sont bien reconnus, ils sont visibles avec le soft OpenBuilds CONTROL

A noter que j'ai un contact à chanque bout d'axe soit 6 en tout.
Avatar du membre
palou72
Pied Tendre
Messages : 5
Enregistré le : 05 janv. 2020, 10:48
Localisation : NOGENT LE BERNARD

Re: branchement des fins de course.

Message non lu par palou72 » 16 juin 2020, 16:00

Bonjour,

J'ai regardé à brancher les fins de courses sur une CN que je suis en train d'équiper, j'ai regardé le config.h que j'ai traduit avec google traduction, pour moi le homing n'est pas très clair, cela me parait compliqué.
Pour ceux que cela intéresse et qui comme moi ne sont pas doué en anglais, je mets la traduction ci-dessous

Code : Tout sélectionner

config.h - configuration de l'heure de compilation
  Partie de Grbl

  Copyright (c) 2012-2016 Sungeun K. Jeon pour Gnea Research LLC
  Copyright (c) 2009-2011 Simen Svale Skogsrud

  Grbl est un logiciel libre: vous pouvez le redistribuer et / ou le modifier
  sous les termes de la GNU General Public License telle que publiée par
  la Free Software Foundation, soit la version 3 de la licence, soit
  (à votre choix) toute version ultérieure.

  Grbl est distribué dans l'espoir qu'il sera utile,
  mais SANS AUCUNE GARANTIE; sans même la garantie implicite de
  QUALITÉ MARCHANDE ou ADÉQUATION À UN USAGE PARTICULIER. Voir le
  Licence publique générale GNU pour plus de détails.

  Vous devriez avoir reçu une copie de la licence publique générale GNU
  avec Grbl. Sinon, voir <http://www.gnu.org/licenses/>.
* /

// Ce fichier contient les configurations de compilation pour le système interne de Grbl. Pour la plupart,
// les utilisateurs n'auront pas besoin de les modifier directement, mais ils sont là pour des besoins spécifiques, c'est-à-dire
// réglage des performances ou ajustement à des machines non typiques.

// IMPORTANT: Toute modification ici nécessite une recompilation complète du code source pour les propager.

#ifndef config_h
#define config_h
#include "grbl.h" // Pour la compatibilité Arduino IDE.


// Définit la carte des broches du CPU et les paramètres par défaut.
// REMARQUE: les fabricants OEM peuvent éviter d'avoir à maintenir / mettre à jour les fichiers defaults.h et cpu_map.h et à utiliser uniquement
// un fichier de configuration en plaçant leurs valeurs par défaut et leur pin map spécifiques au bas de ce fichier.
// Dans ce cas, commentez simplement ces deux définitions et voyez les instructions ci-dessous.
#define DEFAULTS_GENERIC
#define CPU_MAP_ATMEGA328P // Arduino Uno CPU

// Débit en bauds série
// #define BAUD_RATE 230400
#define BAUD_RATE 115200

// Définit les caractères spéciaux des commandes en temps réel. Ces personnages sont «retirés» directement du
// flux de données de lecture en série et ne sont pas transmis à l'analyseur d'exécution de la ligne grbl. Sélectionnez des personnages
// qui n'existent pas et ne doivent pas exister dans le programme g-code streamé. Les caractères de contrôle ASCII peuvent être
// utilisé, s'ils sont disponibles par configuration utilisateur. De plus, les codes ASCII étendus (> 127), qui ne sont jamais en
// Programmes g-code, peut-être sélectionnés pour les programmes d'interface.
// REMARQUE: en cas de modification, mettez à jour manuellement le message d'aide dans report.c.

#define CMD_RESET 0x18 // ctrl-x.
#define CMD_STATUS_REPORT '?'
#define CMD_CYCLE_START '~'
#define CMD_FEED_HOLD '!'

// REMARQUE: toutes les commandes de remplacement en temps réel doivent être dans le jeu de caractères ASCII étendu, en commençant
// à la valeur de caractère 128 (0x80) et jusqu'à 255 (0xFF). Si l'ensemble normal de commandes en temps réel,
// tels que les rapports d'état, le maintien de l'alimentation, la réinitialisation et le démarrage du cycle, sont déplacés vers l'ensemble étendu
// espace, le RX ISR de serial.c devra être modifié pour s'adapter au changement.
// #define CMD_RESET 0x80
// #define CMD_STATUS_REPORT 0x81
// #define CMD_CYCLE_START 0x82
// #define CMD_FEED_HOLD 0x83
#define CMD_SAFETY_DOOR 0x84
#define CMD_JOG_CANCEL 0x85
#define CMD_DEBUG_REPORT 0x86 // Uniquement lorsque DEBUG est activé, envoie un rapport de débogage entre accolades '{}'.
#define CMD_FEED_OVR_RESET 0x90 // Restaure la valeur de remplacement du flux à 100%.
#define CMD_FEED_OVR_COARSE_PLUS 0x91
#define CMD_FEED_OVR_COARSE_MINUS 0x92
#define CMD_FEED_OVR_FINE_PLUS 0x93
#define CMD_FEED_OVR_FINE_MINUS 0x94
#define CMD_RAPID_OVR_RESET 0x95 // Restaure la valeur de remplacement rapide à 100%.
#define CMD_RAPID_OVR_MEDIUM 0x96
#define CMD_RAPID_OVR_LOW 0x97
// #define CMD_RAPID_OVR_EXTRA_LOW 0x98 // * NON PRIS EN CHARGE *
#define CMD_SPINDLE_OVR_RESET 0x99 // Restaure la valeur de remplacement de la broche à 100%.
#define CMD_SPINDLE_OVR_COARSE_PLUS 0x9A
#define CMD_SPINDLE_OVR_COARSE_MINUS 0x9B
#define CMD_SPINDLE_OVR_FINE_PLUS 0x9C
#define CMD_SPINDLE_OVR_FINE_MINUS 0x9D
#define CMD_SPINDLE_OVR_STOP 0x9E
#define CMD_COOLANT_FLOOD_OVR_TOGGLE 0xA0
#define CMD_COOLANT_MIST_OVR_TOGGLE 0xA1

// Si le référencement est activé, le verrouillage init du référencement définit Grbl dans un état d'alarme à la mise sous tension. Cela oblige
// l'utilisateur doit effectuer le cycle de référencement (ou remplacer les verrous) avant de faire quoi que ce soit d'autre. C'est
// principalement une fonction de sécurité pour rappeler à l'utilisateur à la maison, car la position est inconnue de Grbl.
#define HOMING_INIT_LOCK // Commentaire à désactiver

// Définissez les modèles de cycle de référencement avec des masques de bit. Le cycle de référencement effectue d'abord un mode de recherche
// pour enclencher rapidement les fins de course, suivi d'un mode de localisation plus lent et terminé par un court
// mouvement de traction pour désengager les fins de course. Les définitions HOMING_CYCLE_x suivantes sont exécutées
// dans l'ordre commençant par le suffixe 0 et termine la routine de référencement pour les axes spécifiés uniquement. Si
// un axe est omis des définitions, il ne sera pas à la maison, ni le système ne mettra à jour sa position.
// Cela signifie que cela permet aux utilisateurs de machines cartésiennes non standard, comme un tour (x puis z,
// sans y), pour configurer le comportement du cycle de prise d'origine à leurs besoins.
// REMARQUE: le cycle de référencement est conçu pour permettre le partage des broches limites, si les axes ne sont pas dans le même
// cycle, mais cela nécessite quelques modifications des paramètres des broches dans le fichier cpu_map.h. Par exemple, le référencement par défaut
// le cycle peut partager
la broche de limite Z avec des broches de limite X ou Y, car elles sont sur des cycles différents.
// En partageant une broche, cela libère une précieuse broche d'E / S à d'autres fins. En théorie, tous les axes limitent les broches
// peut être réduit à une broche, si tous les axes sont référencés avec des cycles séparés, ou vice versa, les trois axes
// sur broche séparée, mais hébergé dans un cycle. Il convient également de noter que la fonction des limites strictes
// ne sera pas affecté par le partage des broches.
// REMARQUE: les valeurs par défaut sont définies pour une machine CNC 3 axes traditionnelle. Axe Z à effacer en premier, suivi de X et Y.
#define HOMING_CYCLE_0 (1 << Z_AXIS) // REQUIS: déplacez d'abord Z pour effacer l'espace de travail.
#define HOMING_CYCLE_1 ((1 << X_AXIS) | (1 << Y_AXIS)) // FACULTATIF: Déplacez ensuite X, Y en même temps.
// #define HOMING_CYCLE_2 // FACULTATIF: décommenter et ajouter un masque d'axes pour activer

// REMARQUE: voici deux exemples de configuration du référencement pour les machines à 2 axes.
// #define HOMING_CYCLE_0 ((1 << X_AXIS) | (1 << Y_AXIS)) // NON COMPATIBLE AVEC COREXY: héberge les deux X-Y en un seul cycle.

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

// Nombre de cycles de prise d'origine exécutés après que la machine ait initialement fait un jogging pour limiter les interrupteurs.
// Cela aide à prévenir les dépassements et devrait améliorer la répétabilité. Cette valeur doit être un ou
// supérieur.
#define N_HOMING_LOCATE_CYCLE 1 // Entier (1-128)

// Active les commandes de référencement sur un seul axe. $ HX, $ HY et $ HZ pour le référencement des axes X, Y et Z. Le retour complet
// cycle est toujours invoqué par la commande $ H. Ceci est désactivé par défaut. Il est là uniquement pour répondre
// les utilisateurs qui doivent basculer entre une machine à deux axes et une machine à trois axes. C'est en fait très rare.
// Si vous avez une machine à deux axes, NE L'UTILISEZ PAS. Au lieu de cela, modifiez simplement le cycle de référencement pour les deux axes.
// #define HOMING_SINGLE_AXIS_COMMANDS // Par défaut désactivé. Décommentez pour activer.

// Après le référencement, Grbl définira par défaut tout l'espace machine dans un espace négatif, comme c'est typique
// pour les machines CNC professionnelles, quel que soit l'emplacement des fins de course. Décommentez ceci
// définir pour forcer Grbl à toujours définir l'origine de la machine à l'emplacement d'origine malgré l'orientation du commutateur.
// #define HOMING_FORCE_SET_ORIGIN // Décommentez pour activer.

// Nombre de blocs que Grbl exécute au démarrage. Ces blocs sont stockés dans l'EEPROM, où la taille
// et les adresses sont définies dans settings.h. Avec les paramètres actuels, jusqu'à 2 blocs de démarrage peuvent
// être stocké et exécuté dans l'ordre. Ces blocs de démarrage sont généralement utilisés pour définir le code G
// état de l'analyseur en fonction des préférences de l'utilisateur.
#define N_STARTUP_LINE 2 // Entier (1-2)

// Nombre de points décimaux flottants imprimés par Grbl pour certains types de valeurs. Ces paramètres sont
// déterminé par des valeurs réalistes et couramment observées dans les machines CNC. Par exemple, position
// les valeurs ne peuvent pas être inférieures à 0,001 mm ou 0,0001 pouce, car les machines ne peuvent pas être physiquement plus
// précise cela. Il n'est donc probablement pas nécessaire de les modifier, mais vous pouvez le faire si vous en avez besoin ici.
// REMARQUE: Doit être une valeur entière de 0 à ~ 4. Plus de 4 peuvent présenter des erreurs d'arrondi.
#define N_DECIMAL_COORDVALUE_INCH 4 // Coordonner ou positionner la valeur en pouces
#define N_DECIMAL_COORDVALUE_MM 3 // Coordonner ou positionner la valeur en mm
#define N_DECIMAL_RATEVALUE_INCH 1 // Valeur de vitesse ou de vitesse en in / min
#define N_DECIMAL_RATEVALUE_MM 0 // Valeur de vitesse ou de vitesse en mm / min
#define N_DECIMAL_SETTINGVALUE 3 // Décimales pour les valeurs de réglage en virgule flottante
#define N_DECIMAL_RPMVALUE 0 // Valeur RPM en rotations par minute.

// Si votre machine possède deux interrupteurs de fin de course câblés en parallèle sur un axe, vous devrez activer
// cette fonctionnalité. Étant donné que les deux commutateurs partagent une seule broche, Grbl n'a aucun moyen de dire
// lequel est activé. Cette option n'affecte que le référencement, où si une limite est engagée, Grbl
// déclenche l'alarme et force l'utilisateur à désengager manuellement le fin de course. Sinon, si vous en avez un
// fin de course pour chaque axe, n'activez pas cette option. En le désactivant, vous pouvez effectuer une
// cycle de prise d'origine lorsque vous êtes sur le fin de course et ne pas avoir à déplacer la machine hors de celui-ci.
// #define LIMITS_TWO_SWITCHES_ON_AXES

// Permet à GRBL de suivre et de signaler les numéros de ligne gcode. Activer cela signifie que le tampon de planification
// passe de 16 à 15 pour faire de la place pour les données de numéro de ligne supplémentaires dans la structure plan_block_t
// #define USE_LINE_NUMBERS // Désactivé par défaut. Décommentez pour activer.

// Lors d'un cycle de sonde réussi, cette option fournit immédiatement un retour des coordonnées de la sonde
// via un message généré automatiquement. Si désactivé, les utilisateurs peuvent toujours accéder à la dernière sonde
// coordonne les paramètres d'impression Grbl '$ #'.
#define MESSAGE_PROBE_COORDINATES // Activé par défaut. Commentaire à désactiver.

// Active une deuxième broche de contrôle du liquide de refroidissement via la commande M7 du code g du liquide de refroidissement du brouillard sur l'Arduino Uno
// broche analogique 4. Utilisez cette option uniquement si vous avez besoin d'une deuxième broche de contrôle du liquide de refroidissement.
// NE PASE: La broche de commande du liquide de refroidissement M8 sur la broche analogique 3 sera toujours fonctionnelle malgré tout.
// #define ENABLE_M7 // Désactivé par défaut. Décommentez pour activer.

// Cette option fait que l'entrée de maintien d'alimentation agit comme un interrupteur de porte de sécurité. Une porte de sécurité, lorsqu'elle est déclenchée,
// force immédiatement un arrêt d'alimentation puis met hors tension la machine en toute sécurité. La reprise est bloquée jusqu'à
// la porte de sécurité est réenclenchée. Quand c'est le cas, Grbl remettra la machine sous tension, puis reprendra
// chemin d'outil précédent, comme si rien ne s'était passé.
// #define ENABLE_SAFETY_DOOR_INPUT_PIN // Par défaut désactivé. Décommentez pour activer.

// Une fois le commutateur de porte de sécurité basculé et restauré, ce paramètre définit le délai de mise sous tension
// entre la restauration de la broche et du liquide de refroidissement et la reprise du cycle.
#define SAFETY_DOOR_SPINDLE_DELAY 4.0 // Flottant (secondes)
#define SAFETY_DOOR_COOLANT_DELAY 1.0 // Flottant (secondes)

// Activez la cinématique CoreXY. Utilisez UNIQUEMENT avec les machines CoreXY.
// IMPORTANT: si le référencement est activé, vous devez reconfigurer le cycle de référencement #defines ci-dessus pour
// #define HOMING_CYCLE_0 (1 << X_AXIS) et #define HOMING_CYCLE_1 (1 << Y_AXIS)
// REMARQUE: cette option de configuration modifie le mouvement des axes X et Y selon le principe de fonctionnement
// défini sur (http://corexy.com/theory.html). Les moteurs sont supposés positionnés et câblés exactement comme
// décrit, sinon, les mouvements peuvent se déplacer dans des directions étranges. Grbl nécessite les moteurs CoreXY A et B
// avoir les mêmes pas par mm en interne.
// #define COREXY // Par défaut désactivé. Décommentez pour activer.

// Inverse la logique des broches des broches de commande de contrôle en fonction d'un masque. Cela signifie essentiellement que vous pouvez utiliser
// commutateurs normalement fermés sur les broches spécifiées, plutôt que les commutateurs normalement ouverts par défaut.
// REMARQUE: L'option supérieure masquera et inversera toutes les broches de contrôle. L'option du bas est un exemple de
// inverser seulement deux broches de contrôle, la porte de sécurité et réinitialiser. Voir cpu_map.h pour d'autres définitions de bits.
// #define INVERT_CONTROL_PIN_MASK CONTROL_MASK // Par défaut désactivé. Décommentez pour désactiver.
// #define INVERT_CONTROL_PIN_MASK ((1 << CONTROL_SAFETY_DOOR_BIT) | (CONTROL_RESET_BIT)) // Par défaut désactivé.

// Inverse la sélection des états des broches limites en fonction du masque suivant. Cela affecte toutes les fonctions de broche limite,
// comme les limites strictes et le référencement. Cependant, ceci est différent du réglage global des limites d'inversion.
// Cette option de construction inversera uniquement les broches de limite définies ici, puis le paramètre d'inversion des limites
// sera appliqué à chacun d'eux. Ceci est utile lorsqu'un utilisateur a un ensemble mixte de broches de limite avec les deux
// interrupteurs normalement ouverts (NO) et normalement fermés (NC) installés sur leur machine.
// REMARQUE: VEUILLEZ NE PAS UTILISER CELA, sauf si vous avez une situation qui en a besoin.
// #define INVERT_LIMIT_PIN_MASK ((1 << X_LIMIT_BIT) | (1 << Y_LIMIT_BIT)) // Par défaut désactivé. Décommentez pour activer.

// Inverse la broche d'activation de la broche de bas-désactivé / haut-activé à bas-activé / haut-désactivé. Utile
// pour certaines cartes électroniques prédéfinies.
// REMARQUE: si VARIABLE_SPINDLE est activé (par défaut), cette option n'a aucun effet en tant que sortie PWM et
// l'activation de la broche est combinée à une broche. Si vous avez besoin de cette option et de la vitesse de broche PWM,
// décommentez l'option de configuration USE_SPINDLE_DIR_AS_ENABLE_PIN ci-dessous.
// #define INVERT_SPINDLE_ENABLE_PIN // Par défaut désactivé. Décommentez pour activer.

// Inverse la goupille de liquide de refroidissement sélectionnée de faible désactivée / haute activée à faible activée / haute désactivée. Utile
// pour certaines cartes électroniques prédéfinies.
// #define INVERT_COOLANT_FLOOD_PIN // Par défaut désactivé. Décommentez pour activer.
// #define INVERT_COOLANT_MIST_PIN // Par défaut désactivé. Remarque: Activez le liquide de refroidissement M7 dans config.h

// Lorsque Grbl se met sous tension ou est réinitialisé à l'aide du bouton de réinitialisation Arduino, Grbl démarre sans ALARME
// par défaut. C'est pour rendre aussi simple que possible pour les nouveaux utilisateurs de commencer à utiliser Grbl. Lors du retour
// est activé et un utilisateur a installé des interrupteurs de fin de course, Grbl démarrera dans un état ALARME pour indiquer
// Grbl ne connaît pas sa position et force l'utilisateur à rentrer avant de continuer. Cette option oblige
// Grbl pour toujours s'initialiser dans un état ALARME indépendamment du référencement ou non. Cette option est plus pour
// OEM et utilisateurs LinuxCNC qui souhaiteraient ce comportement de cycle d'alimentation.
// #define FORCE_INITIALIZATION_ALARM // Par défaut désactivé. Décommentez pour activer.

// À la mise sous tension ou à une réinitialisation, Grbl vérifiera les états des interrupteurs de fin de course pour s'assurer qu'ils ne sont pas actifs
// avant l'initialisation. S'il détecte un problème et que le paramètre de limites strictes est activé, Grbl
// simplement envoyer un message à l'utilisateur pour vérifier les limites et entrer dans un état d'alarme, plutôt que d'inactivité. Grbl sera
// ne lance pas de message d'alarme.
#define CHECK_LIMITS_AT_INIT

// ------------------------------------------------ ---------------------------------------
// OPTIONS DE CONFIGURATION AVANCÉES:

// Active le code à des fins de débogage. Pas pour une utilisation générale et toujours en flux constant.
// #define DEBUG // Décommentez pour l'activer. Par défaut désactivé.

// Configurez les paramètres de rapidité, d'avance et de remplacement de la broche. Ces valeurs définissent le max et le min
// autorisé oles valeurs de verride et les incréments grossiers et fins par commande reçue. S'il vous plaît
// notez les valeurs autorisées dans les descriptions qui suivent chaque définition.
#define DEFAULT_FEED_OVERRIDE 100 // 100%. Ne modifiez pas cette valeur.
#define MAX_FEED_RATE_OVERRIDE 200 // Pourcentage de l'avance programmée (100-255). Généralement 120% ou 200%
#define MIN_FEED_RATE_OVERRIDE 10 // Pourcentage de l'avance programmée (1-100). Habituellement 50% ou 1%
#define FEED_OVERRIDE_COARSE_INCREMENT 10 // (1-99). Habituellement 10%.
#define FEED_OVERRIDE_FINE_INCREMENT 1 // (1-99). Habituellement 1%.

#define DEFAULT_RAPID_OVERRIDE 100 // 100%. Ne modifiez pas cette valeur.
#define RAPID_OVERRIDE_MEDIUM 50 // Pourcentage de rapide (1-99). Habituellement 50%.
#define RAPID_OVERRIDE_LOW 25 // Pourcentage de rapide (1-99). Généralement 25%.
// #define RAPID_OVERRIDE_EXTRA_LOW 5 // * NON PRIS EN CHARGE * Pourcentage de rapide (1-99). Habituellement 5%.

#define DEFAULT_SPINDLE_SPEED_OVERRIDE 100 // 100%. Ne modifiez pas cette valeur.
#define MAX_SPINDLE_SPEED_OVERRIDE 200 // Pourcentage de la vitesse de broche programmée (100-255). Habituellement 200%.
#define MIN_SPINDLE_SPEED_OVERRIDE 10 // Pourcentage de la vitesse de broche programmée (1-100). Habituellement 10%.
#define SPINDLE_OVERRIDE_COARSE_INCREMENT 10 // (1-99). Habituellement 10%.
#define SPINDLE_OVERRIDE_FINE_INCREMENT 1 // (1-99). Habituellement 1%.

// Lorsqu'une commande de fin de programme M2 ou M30 est exécutée, la plupart des états de code g sont restaurés à leurs valeurs par défaut.
// Cette option au moment de la compilation comprend la restauration des valeurs de remplacement de l'avance, de la vitesse rapide et de la vitesse de broche
// à leurs valeurs par défaut à la fin du programme.
#define RESTORE_OVERRIDES_AFTER_PROGRAM_END // Activé par défaut. Commentaire à désactiver.

// Le changement de rapport d'état pour Grbl v1.1 et après a également supprimé la possibilité de désactiver / activer la plupart des données
// champs du rapport. Cela a causé des problèmes aux développeurs de GUI, qui ont dû gérer plusieurs scénarios
// et configurations. L'efficacité accrue du nouveau style de rapport permet à tous les champs de données de
// être envoyé sans problèmes de performances potentiels.
// REMARQUE: Les options ci-dessous ne sont ici qu'un moyen de désactiver certains champs de données si un
// la situation l'exige, mais sachez que les interfaces graphiques peuvent dépendre de ces données. S'il est désactivé, il peut ne pas être compatible.
#define REPORT_FIELD_BUFFER_STATE // Activé par défaut. Commentaire à désactiver.
#define REPORT_FIELD_PIN_STATE // Activé par défaut. Commentaire à désactiver.
#define REPORT_FIELD_CURRENT_FEED_SPEED // Activation par défaut. Commentaire à désactiver.
#define REPORT_FIELD_WORK_COORD_OFFSET // Par défaut activé. Commentaire à désactiver.
#define REPORT_FIELD_OVERRIDES // Par défaut activé. Commentaire à désactiver.
#define REPORT_FIELD_LINE_NUMBERS // Activé par défaut. Commentaire à désactiver.

// Certaines données de rapport d'état ne sont pas nécessaires en temps réel, uniquement par intermittence, car les valeurs ne le sont pas
// change souvent. Les macros suivantes configurent le nombre de fois qu'un rapport d'état doit être appelé avant
// les données associées sont actualisées et incluses dans le rapport d'état. Cependant, si l'une de ces valeurs
// change, Grbl inclura automatiquement ces données dans le prochain rapport de situation, quel que soit le
// le compte est au moment. Cela permet de réduire les frais de communication liés aux rapports à haute fréquence
// et streaming agressif. Il y a aussi un nombre de rafraîchissements occupés et inactifs, qui configure Grbl pour envoyer
// se rafraîchit plus souvent lorsqu'il ne fait rien d'important. Avec une bonne interface graphique, ces données n'ont pas besoin
// à rafraîchir très souvent, de l'ordre de quelques secondes.
// REMARQUE: l'actualisation de l'OMD doit être supérieure ou égale à 2. Le rafraîchissement OVR doit être supérieur ou égal à 1.
#define REPORT_OVR_REFRESH_BUSY_COUNT 20 // (1-255)
#define REPORT_OVR_REFRESH_IDLE_COUNT 10 // (1-255) Doit être inférieur ou égal au nombre occupé
#define REPORT_WCO_REFRESH_BUSY_COUNT 30 // (2-255)
#define REPORT_WCO_REFRESH_IDLE_COUNT 10 // (2-255) Doit être inférieur ou égal au nombre occupé

// La résolution temporelle du sous-système de gestion de l'accélération. Un nombre plus élevé donne plus de douceur
// accélération, particulièrement perceptible sur les machines qui fonctionnent à des vitesses d'avance très élevées, mais peuvent négativement
// impact sur les performances. La valeur correcte pour ce paramètre dépend de la machine, il est donc conseillé de
// définissez cela seulement aussi haut que nécessaire. Les valeurs approximatives réussies peuvent largement varier de 50 à 200 ou plus.
// REMARQUE: la modification de cette valeur modifie également le temps d'exécution d'un segment dans le tampon de segment d'étape.
// Lorsque vous augmentez cette valeur, cela stocke moins de temps global dans le tampon de segment et vice versa. Faire
// certain que le tampon de segment d'étape est augmenté / diminué pour tenir compte de ces changements.
#define ACCELERATION_TICKS_PER_SECOND 100

// Le lissage multi-axes adaptatif (AMASS) est une fonctionnalité avancée qui fait ce que son nom l'indique,
// lissage de la progression des mouvements multi-axes. Cette fonction adoucit le mouvement, en particulier à faible pas
// fréquences inférieures à 10 kHz, où l'aliasing entre les axes de mouvements multi-axes peut provoquer des
// du bruit et secouez votre machine. À des fréquences de pas encore plus basses, AMASS adapts et fournit encore mieux
// lissage par étapes. Voir stepper.c pour plus de détails sur le fonctionnement du système AMASS.
#define ADAPTIVE_MULTI_AXIS_STEP_SMOOTHING // Activation par défaut. Commentaire à désactiver.

// Définit la fréquence de pas maximale autorisée à être écrite en tant que paramètre Grbl. Cette option active une erreur
// archivez le module des paramètres pour éviter que les valeurs des paramètres dépassent cette limitation. Le maximum
// le taux de pas est strictement limité par la vitesse du processeur et changera si autre chose qu'un AVR fonctionne
// à 16 MHz est utilisé.
// REMARQUE: pour l'instant désactivé, il sera activé si l'espace flash le permet.
// #define MAX_STEP_RATE_HZ 30000 // Hz

// Par défaut, Grbl règle toutes les broches d'entrée sur un fonctionnement normal-élevé avec leurs résistances de rappel internes
// activée. Cela simplifie le câblage pour les utilisateurs en ne nécessitant qu'un interrupteur connecté à la terre,
// bien qu'il soit recommandé aux utilisateurs de prendre l'étape supplémentaire de câblage dans le filtre passe-bas pour réduire
// bruit électrique détecté par la broche. Si l'utilisateur inverse la broche dans les paramètres Grbl, cela retourne simplement
// quelle lecture haute ou basse indique un signal actif. En fonctionnement normal, cela signifie que l'utilisateur
// doit connecter un commutateur normal-open, mais s'il est inversé, cela signifie que l'utilisateur doit connecter un
// interrupteur normalement fermé.
// Les options suivantes désactivent les résistances internes de pull-up, définissent les broches à un niveau normal-bas
// opération, et les commutateurs doivent maintenant être connectés à Vcc au lieu de la masse. Cela inverse également le sens
// du paramètre Grbl de broche inversée, où un paramètre inversé signifie maintenant que l'utilisateur doit connecter un
// interrupteur à ouverture normale et vice versa.
// REMARQUE: toutes les broches associées à la fonction sont désactivées, c'est-à-dire les broches de limite XYZ, pas les axes individuels.
// AVERTISSEMENT: lorsque les pull-ups sont désactivés, cela nécessite un câblage supplémentaire avec des résistances pull-down!
// # définir DISABLE_LIMIT_PIN_PULL_UP
// # définir DISABLE_PROBE_PIN_PULL_UP
// # définir DISABLE_CONTROL_PIN_PULL_UP

// Définit quel axe le décalage de longueur d'outil est appliqué. Suppose que la broche est toujours parallèle à
// l'axe sélectionné avec l'outil orienté vers la direction négative. En d'autres termes, un résultat positif
// la valeur de décalage de longueur d'outil est soustraite de l'emplacement actuel.
#define TOOL_LENGTH_OFFSET_AXIS Z_AXIS // Axe z par défaut. Les valeurs valides sont X_AXIS, Y_AXIS ou Z_AXIS.

// Active la tension de sortie variable de la broche pour différentes valeurs de RPM. Sur l'Arduino Uno, la broche
// la broche d'activation produira 5 V pour un régime maximal avec 256 niveaux intermédiaires et 0 V lorsqu'elle est désactivée.
// REMARQUE: IMPORTANT pour Arduino Unos! Lorsqu'elle est activée, la broche de limite Z D11 et la broche activent le commutateur de broche D12!
// La sortie PWM matérielle sur la broche D11 est requise pour les tensions de sortie de broche variables.
#define VARIABLE_SPINDLE // Activé par défaut. Commentaire à désactiver.

// Utilisé uniquement par la sortie de broche variable. Cela force la sortie PWM à un rapport cyclique minimum lorsqu'elle est activée.
// La broche PWM lira toujours 0V lorsque la broche est désactivée. La plupart des utilisateurs n'auront pas besoin de cette option, mais
// il peut être utile dans certains scénarios. Ces paramètres PWM minimum coïncident avec le minimum de vitesse de rotation de la broche
// réglage, comme rpm max à max PWM. C'est pratique si vous avez besoin d'une plus grande différence de tension entre 0V désactivé
// et la tension réglée par le PWM minimum pour un régime minimum. Cette différence est de 0,02 V par valeur PWM. Donc quand
// PWM minimum est à 1, seulement 0,02 volts séparés activés et désactivés. À PWM 5, ce serait 0,1V. Garder
// à l'esprit que vous commencerez à perdre la résolution PWM avec des valeurs PWM minimales accrues, car vous avez moins
// et moins de portée sur les 255 niveaux PWM totaux pour signaler différentes vitesses de broche.
// NOTE: Calculer le rapport cyclique au PWM minimum par cette équation: (% rapport cyclique) = (SPINDLE_PWM_MIN_VALUE / 255) * 100
// #define SPINDLE_PWM_MIN_VALUE 5 // Par défaut désactivé. Décommentez pour activer. Doit être supérieur à zéro. Entier (1-255).

// Par défaut sur un 328p (Uno), Grbl combine le PWM à broche variable et l'activation en une seule broche pour aider
// conserve les broches d'E / S. Pour certaines configurations, il peut être nécessaire que ces broches soient distinctes. Cette option de configuration utilise
// la broche de direction de broche (D13) en tant que broche de validation de broche séparée avec la vitesse de broche PWM sur la broche D11.
// REMARQUE: cette option de configuration fonctionne uniquement avec VARIABLE_SPINDLE activé et un processeur 328p (Uno).
// REMARQUE: sans broche de direction, M4 n'aura pas de sortie de broche pour indiquer une différence avec M3.
// REMARQUE: ATTENTION! Le chargeur de démarrage Arduino bascule la broche D13 lors de sa mise sous tension. Si vous flashez Grbl avec
// un programmeur (vous pouvez utiliser un Arduino de rechange comme "Arduino comme FAI". Recherchez sur le Web comment câbler cela.),
// cette bascule LED D13 devrait disparaître. Nous n'avons pas testé cela cependant. Veuillez indiquer comment cela se passe!
// #define USE_SPINDLE_DIR_AS_ENABLE_PIN // Par défaut désactivé. Décommentez pour activer.

// Modifie le comportement de la broche d'activation de la broche avec l'option USE_SPINDLE_DIR_AS_ENABLE_PIN. Par défaut,
// Grbl ne désactivera pas la broche d'activation si la vitesse de broche est nulle et que M3 / 4 est actif, mais définit toujours le PWM
// sortie à zéro. Cela permet aux utilisateurs de savoir si la broche est active et de l'utilisercomme contrôle supplémentaire
// contribution. Cependant, dans certains cas d'utilisation, l'utilisateur peut souhaiter que la broche d'activation se désactive avec une vitesse de broche nulle et
// réactiver lorsque la vitesse de broche est supérieure à zéro. Cette option fait cela.
// REMARQUE: nécessite USE_SPINDLE_DIR_AS_ENABLE_PIN pour être activé.
// #define SPINDLE_ENABLE_OFF_WITH_ZERO_SPEED // Par défaut désactivé. Décommentez pour activer.

// Avec cette option activée, Grbl renvoie un écho de la ligne qu'il a reçue, qui a été pré-analysée (espaces
// supprimé, lettres majuscules, aucun commentaire) et doit être immédiatement exécuté par Grbl. Les échos ne seront pas
// envoyé lors d'un débordement de tampon de ligne, mais devrait l'être pour toutes les lignes normales envoyées à Grbl. Par exemple, si un utilisateur
// envoie la ligne 'g1 x1.032 y2.45 (commentaire de test)', Grbl réapparaîtra sous la forme '[echo: G1X1.032Y2.45]'.
// REMARQUE: utilisez-le uniquement à des fins de débogage !! En écho, cela prend des ressources précieuses et peut affecter
// performance. S'il est absolument nécessaire pour un fonctionnement normal, le tampon d'écriture série doit être considérablement augmenté
// pour minimiser l'attente de transmission dans le protocole d'écriture série.
// #define REPORT_ECHO_LINE_RECEIVED // Par défaut désactivé. Décommentez pour activer.

// Vitesse minimale de jonction du planificateur. Définit la vitesse de jonction minimale par défaut à laquelle le planificateur prévoit
// chaque jonction de bloc tampon, à l'exception du début du repos et de la fin du tampon, qui sont toujours
// zéro. Cette valeur contrôle la vitesse à laquelle la machine se déplace à travers les jonctions sans tenir compte de l'accélération
// limites ou angle entre les directions de déplacement de la ligne de bloc voisine. Ceci est utile pour les machines qui ne peuvent pas
// tolère le logement de l'outil pendant une fraction de seconde, c'est-à-dire des imprimantes 3D ou des découpeurs laser. Si utilisé, cette valeur
// ne doit pas être bien supérieur à zéro ou à la valeur minimale nécessaire au fonctionnement de la machine.
#define MINIMUM_JUNCTION_SPEED 0.0 // (mm / min)

// Définit la vitesse d'avance minimale autorisée par le planificateur. Toute valeur en dessous sera définie à ce minimum
// valeur. Cela garantit également qu'un mouvement planifié se termine toujours et tient compte de toute virgule flottante
// erreurs d'arrondi. Bien que cela ne soit pas recommandé, une valeur inférieure à 1,0 mm / min fonctionnera probablement
// machines, peut-être à 0,1 mm / min, mais votre succès peut varier en fonction de plusieurs facteurs.
#define MINIMUM_FEED_RATE 1.0 // (mm / min)

// Nombre d'itérations de génération d'arc par approximation à petit angle avant la trajectoire exacte de l'arc
// correction avec des calculs coûteux sin () et cos (). Ce paramètre peut être diminué s'il y a
// sont des problèmes avec la précision des générations d'arc, ou augmentés si l'exécution de l'arc devient
// embourbé par trop de calculs trigonométriques.
#define N_ARC_CORRECTION 12 // Entier (1-255)

// La norme Arc G2 / 3 g-code est problématique par définition. Les arcs basés sur le rayon ont d'horribles chiffres
// erreurs lors d'un arc en demi-cercles (pi) ou en cercles pleins (2 * pi). Les arcs basés sur les décalages sont beaucoup plus précis
// mais a toujours un problème lorsque les arcs sont des cercles pleins (2 * pi). Cela définit les comptes pour le flottant
// pointe les problèmes lorsque les arcs basés sur l'offset sont commandés comme des cercles pleins, mais sont interprétés comme extrêmement
// petits arcs avec autour de la machine epsilon (1.2e-7rad) en raison d'arrondis numériques et de problèmes de précision.
// Cette valeur définie définit la coupure epsilon de la machine pour déterminer si l'arc est un cercle complet ou non.
// REMARQUE: soyez très prudent lorsque vous ajustez cette valeur. Il doit toujours être supérieur à 1,2e-7 mais pas trop
// beaucoup plus que cela. Le paramètre par défaut devrait capturer la plupart, sinon la totalité, des situations d'erreur d'arc complet.
#define ARC_ANGULAR_TRAVEL_EPSILON 5E-7 // Flottant (radians)

// Incréments de temporisation effectués pendant une temporisation. La valeur par défaut est fixée à 50 ms, ce qui fournit
// un délai maximum d'environ 55 minutes, largement suffisant pour la plupart des applications. En augmentant
// ce délai augmentera le temps de séjour maximal de manière linéaire, mais réduira également la réactivité de
// exécutions de commandes au moment de l'exécution, comme les rapports d'état, car elles sont effectuées entre chaque interruption
// pas de temps. Gardez également à l'esprit que le retardateur Arduino n'est pas très précis pour les longs retards.
#define DWELL_TIME_STEP 50 // Entier (1-255) (millisecondes)

// Crée un délai entre le réglage des broches de direction et l'impulsion de pas correspondante en créant
// une autre interruption (Timer2 compare) pour le gérer. L'interruption principale de Grbl (comparaison Timer1)
// définit les broches de direction, et ne définit pas immédiatement les broches pas à pas, comme il le ferait dans
// fonctionnement normal. Le Timer2 compare les feux à côté pour régler les broches pas à pas après l'étape
// temps de retard d'impulsion, et le débordement de Timer2 terminera l'impulsion de pas, sauf maintenant retardé
// par le temps d'impulsion de pas plus le retard d'impulsion de pas. (Merci langwadt pour l'idée!)
// REMARQUE: décommenter pour activer. Le délai recommandé doit être> 3us et, lorsqu'il est ajouté avec le
// temps d'impulsion de pas fourni par l'utilisateur, le temps total ne doit pas dépasser 127us. Signalé avec succès
// les valeurs pour certaines configurations ont varié de 5 à 20us.
// #define STEP_PULSE_DELAY 10 // Retard d'impulsion de pas en microsecondes. Par défaut désactivé.

// Le nombre de liles mouvements proches dans le tampon du planificateur doivent être planifiés à tout moment. La vaste
// la majorité de la RAM que Grbl utilise est basée sur cette taille de tampon. Augmenter uniquement s'il y a un supplément
// RAM disponible, comme lors de la recompilation pour un Mega2560. Ou diminuez si l'Arduino commence à
// crash dû au manque de RAM disponible ou si le CPU a du mal à suivre la planification
// nouveaux mouvements entrants lors de leur exécution.
// #define BLOCK_BUFFER_SIZE 16 // Décommentez pour remplacer la valeur par défaut dans planner.h.

// Régit la taille du tampon de segment d'étape intermédiaire entre l'algorithme d'exécution d'étape
// et les blocs du planificateur. Chaque segment est un ensemble d'étapes exécutées à une vitesse constante sur une
// heure fixe définie par ACCELERATION_TICKS_PER_SECOND. Ils sont calculés de telle sorte que le planificateur
// le profil de vitesse du bloc est tracé exactement. La taille de ce tampon régit le nombre de pas
// délai d'exécution pour les autres processus Grbl doivent calculer et faire leur travail
// avant de devoir revenir et remplir ce tampon, actuellement à ~ 50 ms de pas.
// #define SEGMENT_BUFFER_SIZE 6 // Décommentez pour remplacer la valeur par défaut dans stepper.h.

// Taille du tampon de ligne du flux d'entrée série à exécuter. Régit également la taille de
// chacun des blocs de démarrage, car ils sont chacun stockés sous forme de chaîne de cette taille. Assure-toi
// pour tenir compte de l'EEPROM disponible à l'adresse mémoire définie dans settings.h et pour
// le nombre de blocs de démarrage souhaités.
// REMARQUE: 80 caractères n'est pas un problème, sauf dans les cas extrêmes, mais la taille du tampon de ligne
// peut être trop petit et les blocs de code g peuvent être tronqués. Officiellement, les normes du code g
// prend en charge jusqu'à 256 caractères. Dans les versions futures, cette valeur par défaut sera augmentée lorsque
// nous savons combien d'espace mémoire supplémentaire nous pouvons réinvestir dans cela.
// #define LINE_BUFFER_SIZE 80 // Décommenter pour remplacer la valeur par défaut dans protocol.h

// Taille du tampon d'envoi et de réception en série. Le tampon de réception est souvent utilisé comme un autre streaming
// tampon pour stocker les blocs entrants à traiter par Grbl lorsqu'il est prêt. Le plus de streaming
// les interfaces compteront les caractères et suivront chaque bloc envoyé à chaque réponse de bloc. Donc,
// augmente le tampon de réception si un tampon de réception plus profond est nécessaire pour le streaming et disponible
// la mémoire le permet. Le tampon d'envoi gère principalement les messages dans Grbl. N'augmenter que si grand
// les messages sont envoyés et Grbl commence à se bloquer, attendant d'envoyer le reste du message.
// REMARQUE: Grbl génère un rapport d'état moyen en environ 0,5 ms, mais le flux TX série à
// 115200 bauds prendront 5 ms pour transmettre un rapport typique de 55 caractères. Les pires signalements sont
// environ 90-100 caractères. Tant que le tampon série TX n'est pas continuellement maximisé, Grbl
// continuera de fonctionner efficacement. Dimensionnez le tampon TX autour de la taille du pire rapport.
// #define RX_BUFFER_SIZE 128 // (1-254) Décommenter pour remplacer les valeurs par défaut dans serial.h
// #define TX_BUFFER_SIZE 100 // (1-254)

// Une fonction anti-rebond simple pour les interrupteurs de fin de course. Lorsqu'elle est activée, l'interruption
// la surveillance des broches de l'interrupteur de fin de course permettra au minuteur de surveillance de l'Arduino de revérifier
// l'état limite des broches après un délai d'environ 32 ms. Cela peut aider avec les machines CNC avec
// faux déclenchement problématique de leurs interrupteurs de fin de course, mais cela NE résoudra PAS les problèmes avec
// interférences électriques sur les câbles de signaux provenant de sources externes. Il est recommandé de commencer
// utiliser des câbles de signaux blindés avec leur blindage connecté à la masse (vieux câbles USB / ordinateur
// fonctionnent bien et sont bon marché à trouver) et câbler dans un circuit passe-bas dans chaque broche de limite.
// #define ENABLE_SOFTWARE_DEBOUNCE // Par défaut désactivé. Décommentez pour activer.

// Configure la position après un cycle de palpage en mode de vérification de Grbl. Ensembles désactivés
// la position sur la cible de la sonde, lorsqu'elle est activée, définit la position sur la position de départ.
// #define SET_CHECK_MODE_PROBE_TO_START // Par défaut désactivé. Décommentez pour activer.

// Forcer Grbl à vérifier l'état des fins de course fixes lorsque le processeur détecte une broche
// modification à l'intérieur de la routine ISR de limite stricte. Par défaut, Grbl déclenchera les limites strictes
// alarme lors de tout changement de broche, car les commutateurs qui rebondissent peuvent provoquer une vérification d'état comme celle-ci
// a mal lu la broche. Lorsque des limites strictes sont déclenchées, elles doivent être fiables à 100%, ce qui est le
// raison pour laquelle cette option est désactivée par défaut. Seulement si votre système / électronique peut garantir
// que les commutateurs ne rebondissent pas, nous vous recommandons d'activer cette option. Cela aidera à prévenir
// déclencher une limite stricte lorsque la machine se désengage du commutateur.
// REMARQUE: cette option n'a aucun effet si SOFTWARE_DEBOUNCE est activé.
// #define HARD_LIMIT_FORCE_STATE_CHECK // Par défaut désactivé. Décommentez pour activer.

// Ajuste la recherche du cycle de référence et localise les scalaires. Ce sont les multiplicateurs utilisés par Grbl's
// cycle de prise d'origine pour garantir que les interrupteurs de fin de course sont enclenchés et effacés à chaque phase de
// le cycle. La phase de recherche utilise les axes de réglage de la course maximale fois SEARCH_SCALAR pour
// déterminerdistance pour rechercher le fin de course. Une fois trouvé, la phase de localisation commence et
// utilise le temps de réglage de la distance de retour au point d'origine LOCATE_SCALAR pour retirer et réengager
// le fin de course.
// REMARQUE: ces deux valeurs doivent être supérieures à 1,0 pour garantir le bon fonctionnement.
// #define HOMING_AXIS_SEARCH_SCALAR 1.5 // Décommentez pour remplacer les valeurs par défaut dans limits.c.
// #define HOMING_AXIS_LOCATE_SCALAR 10.0 // Décommentez pour remplacer les valeurs par défaut dans limits.c.

// Activez les commandes de restauration eeprom '$ RST = *', '$ RST = $' et '$ RST = #'. Il y a des cas où
// ces commandes peuvent être indésirables. Il vous suffit de commenter la macro souhaitée pour la désactiver.
// REMARQUE: Voir la macro SETTINGS_RESTORE_ALL pour personnaliser la commande `$ RST = *`.
#define ENABLE_RESTORE_EEPROM_WIPE_ALL // '$ RST = *' Activé par défaut. Commentaire à désactiver.
#define ENABLE_RESTORE_EEPROM_DEFAULT_SETTINGS // '$ RST = $' Activé par défaut. Commentaire à désactiver.
#define ENABLE_RESTORE_EEPROM_CLEAR_PARAMETERS // '$ RST = #' Activé par défaut. Commentaire à désactiver.

// Définit les données EEPROM restaurées lors d'un changement de version des paramètres et de la commande `$ RST = *`. Chaque fois que
// les paramètres ou autres modifications de la structure des données EEPROM entre les versions de Grbl, Grbl
// essuyez et restaurez l'EEPROM. Cette macro contrôle quelles données sont effacées et restaurées. C'est utile
// en particulier pour les OEM qui ont besoin de conserver certaines données. Par exemple, la chaîne BUILD_INFO peut être
// écrit dans l'AEPROM Arduino via un croquis .INO séparé pour contenir les données du produit. Modifier cela
// macro pour ne pas restaurer les informations de build L'EEPROM garantit que ces données sont conservées après les mises à niveau du firmware.
// REMARQUE: décommentez pour remplacer les valeurs par défaut dans settings.h
// #define SETTINGS_RESTORE_ALL (SETTINGS_RESTORE_DEFAULTS | SETTINGS_RESTORE_PARAMETERS | SETTINGS_RESTORE_STARTUP_LINES | SETTINGS_RESTORE_BUILD_INFO)

// Activez la commande d'écriture d'informations de construction '$ I = (chaîne)'. Si elle est désactivée, toutes les données d'informations de construction existantes doivent
// être placé dans l'EEPROM via des moyens externes avec une valeur de somme de contrôle valide. Cette option de macro est utile
// pour éviter que ces données ne soient écrasées par un utilisateur, lorsqu'elles sont utilisées pour stocker des données produit OEM.
// REMARQUE: si désactivé et pour garantir que Grbl ne puisse jamais modifier la ligne d'informations de construction, vous devrez également activer
// la macro SETTING_RESTORE_ALL ci-dessus et supprimez SETTINGS_RESTORE_BUILD_INFO du masque.
// REMARQUE: Voir le fichier d'exemple grblWrite_BuildInfo.ino inclus pour écrire cette chaîne séparément.
#define ENABLE_BUILD_INFO_WRITE_COMMAND // '$ I =' Activé par défaut. Commentaire à désactiver.

// Les processeurs AVR nécessitent que toutes les interruptions soient désactivées lors d'une écriture EEPROM. Cela comprend à la fois
// les ISR pas à pas et les ISR de communication série. En cas de longue écriture EEPROM, cette pause ISR peut
// provoque la perte de position du pas actif et la perte des données de réception en série. Cette configuration
// L'option force le tampon du planificateur à se vider complètement chaque fois que l'EEPROM est écrite pour empêcher
// toute chance de pas perdu.
// Cependant, cela n'empêche pas les problèmes de perte de données RX série lors d'une écriture EEPROM, en particulier
// si une interface graphique remplit le tampon RX série simultanément. Il est fortement conseillé pour
// GUI pour marquer ces gcodes (G10, G28.1, G30.1) pour toujours attendre un "ok" après un bloc contenant
// une de ces commandes avant d'envoyer plus de données pour éliminer ce problème.
// REMARQUE: la plupart des commandes d'écriture EEPROM sont implicitement bloquées pendant un travail (toutes les commandes '$'). cependant,
// les commandes du jeu de coordonnées g-code (G10, G28 / 30.1) ne le sont pas, car elles font partie d'un streaming actif
// emploi. Pour le moment, cette option force uniquement une synchronisation du tampon du planificateur avec ces commandes de code g.
#define FORCE_BUFFER_SYNC_DURING_EEPROM_WRITE // Activé par défaut. Commentaire à désactiver.

// Dans Grbl v0.9 et versions antérieures, il existe un ancien bogue en suspens où la position de travail `WPos:` a été signalée
// peut ne pas correspondre à ce qui est en cours d'exécution, car `WPos:` est basé sur l'état de l'analyseur de code g, qui
// peut avoir plusieurs mouvements derrière. Cette option force le tampon du planificateur à se vider, à se synchroniser et à s'arrêter
// mouvement chaque fois qu'il existe une commande qui modifie les décalages des coordonnées de travail `G10, G43.1, G92, G54-59`.
// C'est le moyen le plus simple de s'assurer que `WPos:` est toujours correct. Heureusement, c'est extrêmement rare
// que n'importe laquelle de ces commandes est utilisée nécessite des mouvements continus à travers elles.
#define FORCE_BUFFER_SYNC_DURING_WCO_CHANGE // Activation par défaut. Commentaire à désactiver.

// Par défaut, Grbl désactive les remplacements de vitesse d'avance pour toutes les commandes de cycle de sonde G38.x. Bien que cela
// peut être différent de certains contrôles de machines de classe professionnelle, on peut soutenir qu'il devrait en être ainsi.
// La plupart des capteurs de sonde produisent différents niveaux d'erreur qui dépendent du taux de vitesse. Par
// en gardant les cycles de sondage à leur vitesse d'avance programmée, le capteur de la sonde devrait être beaucoup plus
// répétable. Si nécessaire, vous pouvez désactiver ce comportement en décommentant la définition ci-dessous.
// #define ALLOW_FEED_OVERRIDE_DURING_PROBE_CYCLES // Par défaut désactivé. Décommentez pour activer.

// Active et configure les méthodes de mouvement de stationnement sur un état de porte de sécurité. Primarily pour les OEM
// qui souhaitent cette fonctionnalité pour leurs machines intégrées. Pour le moment, Grbl suppose que
// le mouvement de stationnement ne concerne qu'un seul axe, bien que l'implémentation du stationnement ait été écrite
// être facilement refactorisé pour n'importe quel nombre de mouvements sur différents axes en modifiant le stationnement
// code source. Pour le moment, Grbl prend uniquement en charge le stationnement d'un axe (généralement l'axe Z) qui
// se déplace dans le sens positif lors de la rétraction et dans le sens négatif lors de la restauration de la position.
// Le mouvement s'exécute avec un mouvement de rétraction à extraction lente, une mise hors tension et un stationnement rapide.
// La restauration à la position de reprise suit ces mouvements définis en sens inverse: restauration rapide vers
// position de retrait, mise sous tension avec un temps mort et replonger à la position d'origine au
// taux de retrait plus lent.
// NOTE: Encore un travail en cours. Les coordonnées de la machine doivent être dans tous les espaces négatifs et
// ne fonctionne pas avec HOMING_FORCE_SET_ORIGIN activé. Le mouvement de stationnement se déplace également uniquement dans
// direction positive.
// #define PARKING_ENABLE // Par défaut désactivé. Décommenter pour activer

// Configurez les options du mouvement de stationnement, si activé.
#define PARKING_AXIS Z_AXIS // Définit quel axe qui effectue le mouvement de stationnement
#define PARKING_TARGET -5.0 // Cible de l'axe de stationnement. En mm, comme coordonnée machine [-max_travel, 0].
#define PARKING_RATE 500.0 // Vitesse de stationnement rapide après extraction en mm / min.
#define PARKING_PULLOUT_RATE 100.0 // Vitesse d'avance lente en sortie / en plongée en mm / min.
#define PARKING_PULLOUT_INCREMENT 5.0 // Distance de retrait et de plongée de la broche en mm. Distance incrémentale.
                                      // Doit être une valeur positive ou égale à zéro.

// Active un ensemble spécial de commandes de code M qui active et désactive le mouvement de stationnement.
// Ceux-ci sont contrôlés par `M56`,` M56 P1` ou `M56 Px` pour activer et` M56 P0` pour désactiver.
// La commande est modale et sera définie après une synchronisation du planificateur. Puisqu'il s'agit d'un code g, il est
// exécuté en synchronisation avec les commandes g-code. Ce n'est pas une commande en temps réel.
// REMARQUE: PARKING_ENABLE est requis. Par défaut, M56 est actif lors de l'initialisation. Utilisation
// DEACTIVATE_PARKING_UPON_INIT pour définir M56 P0 comme valeur par défaut à la mise sous tension.
// #define ENABLE_PARKING_OVERRIDE_CONTROL // Par défaut désactivé. Décommenter pour activer
// #define DEACTIVATE_PARKING_UPON_INIT // Par défaut désactivé. Décommentez pour activer.

// Cette option désactivera automatiquement le laser pendant un maintien d'avance en invoquant un arrêt de broche
// remplacer immédiatement après l'arrêt. Cependant, cela signifie également que le laser peut encore
// être réactivé en désactivant le remplacement d'arrêt de broche, si nécessaire. Ceci est purement une caractéristique de sécurité
// pour s'assurer que le laser ne reste pas alimenté par inadvertance lors d'un arrêt et provoque un incendie.
#define DISABLE_LASER_DURING_HOLD // Par défaut activé. Commentaire à désactiver.

// Active un modèle linéaire par morceaux de la sortie PWM / vitesse de la broche. Nécessite une solution par le
// Script 'fit_nonlinear_spindle.py' dans le dossier / doc / script du dépôt. Voir les commentaires sur le fichier
// sur la façon de collecter des données de broche et d'exécuter le script pour générer une solution.
// #define ENABLE_PIECEWISE_LINEAR_SPINDLE // Par défaut désactivé. Décommentez pour activer.

// Les constantes N_PIECES, RPM_MAX, RPM_MIN, RPM_POINTxx et RPM_LINE_XX sont toutes définies et données par
// la solution de script 'fit_nonlinear_spindle.py'. Utilisé uniquement lorsque ENABLE_PIECEWISE_LINEAR_SPINDLE
// est autorisé. Assurez-vous que les valeurs constantes sont exactement les mêmes que la solution de script.
// REMARQUE: lorsque N_PIECES <4, les définitions RPM_LINE et RPM_POINT inutilisées ne sont pas requises et omises.
#define N_PIECES 4 // Entier (1-4). Nombre de lignes par morceaux utilisées dans la solution de script.
#define RPM_MAX 11686.4 // RPM max du modèle. 30 $> RPM_MAX sera limité à RPM_MAX.
#define RPM_MIN 202.5 // RPM minimum du modèle. 31 $ <RPM_MIN sera limité à RPM_MIN.
#define RPM_POINT12 6145.4 // N_PIECES utilisé> = 2. Point de jonction entre les lignes 1 et 2.
#define RPM_POINT23 9627.8 // N_PIECES utilisé> = 3. Point de jonction entre les lignes 2 et 3.
#define RPM_POINT34 10813.9 // N_PIECES utilisé = 4. Point de jonction entre les lignes 3 et 4.
#define RPM_LINE_A1 3.197101e-03 // N_PIECES utilisé> = 1. Constantes A et B de la ligne 1.
#define RPM_LINE_B1 -3.526076e-1
#define RPM_LINE_A2 1.722950e-2 // N_PIECES utilisé> = 2. Constantes A et B de la ligne 2.
#define RPM_LINE_B2 8.588176e + 01
#define RPM_LINE_A3 5.901518e-02 // N_PIECES utilisé> = 3. Constantes A et B de la ligne 3.
#define RPM_LINE_B3 4.881851e + 02
#define RPM_LINE_A4 1.203413e-01 // N_PIECES = 4. Constantes A et B de la ligne 4 utilisées.
#define RPM_LINE_B4 1.151360e + 03


/ * ------------------------------------------------ ---------------------------------------
   Option de configuration de fichier unique OEM

   Instructions: collez les définitions de cpu_map et des paramètres par défaut ci-dessous sans entourer
   #ifdef. Mettez en commentaire les définitions CPU_MAP_xxx et DEFAULT_xxx en haut de ce fichier, et
   le compilateur ignorera le contenu de defaults.h et cpu_map.h et utilisera les définitions
   au dessous de.
* /

// Collez les définitions CPU_MAP ici.

// Coller de définitions des paramètres de défaut ici.
--------- !*m1#fin si
Avatar du membre
DranerB
Administrateur
Messages : 2079
Enregistré le : 31 janv. 2019, 11:56
Localisation : Bourbon-Lancy, France
A remercié : 109 fois
A été remercié : 215 fois
Contact :

Re: branchement des fins de course.

Message non lu par DranerB » 16 juin 2020, 18:29

J'ai regardé à brancher les fins de courses sur une CN que je suis en train d'équiper, j'ai regardé le config.h que j'ai traduit avec google traduction, pour moi le homing n'est pas très clair, cela me parait compliqué.
Pour ceux que cela intéresse et qui comme moi ne sont pas doué en anglais, je mets la traduction ci-dessous
C'est très bien, mais il n'y a aucune raison d'aller toucher au config.h pour faire le homing correctement. Cela peut être utile dans certains cas particuliers, qui, par définition, sont rares. (2 switches sur un même axe, du même coté, par exemple)

La procédure de homing est décrite ici, et est plutôt simple et logique : https://github.com/gnea/grbl/wiki/Set-u ... ycle-steps

Qu'est-ce qui te paraît compliqué ? N'hésites pas à poser des questions.

Lire la totalité du config.h est BEAUCOUP plus compliqué que de faire le nécessaire pour avoir un homing fonctionnel.
Cette lecture est, je crois, simple aussi, et comporte une traduction de la procédure originale passée en lien:
https://lebearcnc.com/grbl-homing-et-fins-de-course/

PS: Quand tu passes du code comme ça, surtout aussi long, utilise la balise code (Icone </> ci-dessus)
Bien Cordialement,
Bernard
Image
Avatar du membre
Grain de femmes
Compagnon
Messages : 108
Enregistré le : 23 mai 2020, 00:36
A remercié : 7 fois
A été remercié : 3 fois

Re: branchement des fins de course.

Message non lu par Grain de femmes » 20 juin 2020, 10:46

Bonjour, plus d'info sur les fin de courses ici voilà si ça peut aider ...
la passion de l'image Site Web
Avatar du membre
DranerB
Administrateur
Messages : 2079
Enregistré le : 31 janv. 2019, 11:56
Localisation : Bourbon-Lancy, France
A remercié : 109 fois
A été remercié : 215 fois
Contact :

Re: branchement des fins de course.

Message non lu par DranerB » 20 juin 2020, 11:56

Grain de femmes a écrit :
20 juin 2020, 10:46
Bonjour, plus d'info sur les fin de courses ici voilà si ça peut aider ...
En fait, tout ce qui est décrit sur cette page est déjà intégré à la dernière version du shield CNC Protoneer. Attention, ce n'est pas le cas pour les clones chinois. C'est aussi intégré sur la carte de l'Arduino club Allemand.
Bien Cordialement,
Bernard
Image
Répondre