From a7adc66ae528571b0b514702f274301ad3b8ba20 Mon Sep 17 00:00:00 2001 From: Markus Hitter Date: Sun, 25 May 2014 18:43:29 +0200 Subject: [PATCH] config.*.h: distribute adaptive homing feedrate to all templates. --- config.gen3.h | 30 +++++++++++++++++++++++++----- config.gen6.h | 30 +++++++++++++++++++++++++----- config.gen7-v1.1-v1.3.h | 30 +++++++++++++++++++++++++----- config.gen7-v1.4.h | 30 +++++++++++++++++++++++++----- config.ramps-v1.2.h | 30 +++++++++++++++++++++++++----- config.ramps-v1.3.h | 30 +++++++++++++++++++++++++----- config.sanguinololu-v1.1.h | 30 +++++++++++++++++++++++++----- config.sanguinololu-v1.2.h | 30 +++++++++++++++++++++++++----- config.sanguish.h | 30 +++++++++++++++++++++++++----- config.teensy.h | 30 +++++++++++++++++++++++++----- config.teensypp.h | 30 +++++++++++++++++++++++++----- 11 files changed, 275 insertions(+), 55 deletions(-) diff --git a/config.gen3.h b/config.gen3.h index 829bb32..b497d1d 100644 --- a/config.gen3.h +++ b/config.gen3.h @@ -83,17 +83,37 @@ #define MAXIMUM_FEEDRATE_Z 100 #define MAXIMUM_FEEDRATE_E 200 -/// used when searching endstops and as default feedrate +/// Used when doing precision endstop search and as default feedrate. #define SEARCH_FEEDRATE_X 50 #define SEARCH_FEEDRATE_Y 50 #define SEARCH_FEEDRATE_Z 50 // no SEARCH_FEEDRATE_E, as E can't be searched -/** \def SLOW_HOMING - wether to search the home point slowly - With some endstop configurations, like when probing for the surface of a PCB, you can't deal with overrunning the endstop. In such a case, uncomment this definition. +/** \def ENDSTOP_CLEARANCE_X + \def ENDSTOP_CLEARANCE_Y + \def ENDSTOP_CLEARANCE_Z + + When hitting an endstop, Teacup properly decelerates instead of doing an + aprupt stop to save your mechanics. Ineviteably, this means it overshoots + the endstop trigger point by some distance. + + To deal with this, Teacup adapts homing movement speeds to what your + endstops can deal with. The higher the allowed acceleration ( = deceleration, + see #define ACCELERATION) and the more clearance the endstop comes with, + the faster Teacup will do homing movements. + + Set here how many micrometers (mm * 1000) your endstop allows the carriage + to overshoot the trigger point. Typically 1000 or 2000 for mechanical + endstops, more for optical ones. You can set it to zero, in which case + SEARCH_FEEDRATE_{XYZ} is used, but expect very slow homing movements. + + Units: micrometers + Sane values: 0 to 20000 (0 to 20 mm) + Valid range: 0 to 1000000 */ -// #define SLOW_HOMING +#define ENDSTOP_CLEARANCE_X 1000 +#define ENDSTOP_CLEARANCE_Y 1000 +#define ENDSTOP_CLEARANCE_Z 100 /** Soft axis limits, in mm. diff --git a/config.gen6.h b/config.gen6.h index 476a210..86ed49a 100644 --- a/config.gen6.h +++ b/config.gen6.h @@ -84,17 +84,37 @@ #define MAXIMUM_FEEDRATE_Z 100 #define MAXIMUM_FEEDRATE_E 200 -/// used when searching endstops and as default feedrate +/// Used when doing precision endstop search and as default feedrate. #define SEARCH_FEEDRATE_X 50 #define SEARCH_FEEDRATE_Y 50 #define SEARCH_FEEDRATE_Z 50 // no SEARCH_FEEDRATE_E, as E can't be searched -/** \def SLOW_HOMING - wether to search the home point slowly - With some endstop configurations, like when probing for the surface of a PCB, you can't deal with overrunning the endstop. In such a case, uncomment this definition. +/** \def ENDSTOP_CLEARANCE_X + \def ENDSTOP_CLEARANCE_Y + \def ENDSTOP_CLEARANCE_Z + + When hitting an endstop, Teacup properly decelerates instead of doing an + aprupt stop to save your mechanics. Ineviteably, this means it overshoots + the endstop trigger point by some distance. + + To deal with this, Teacup adapts homing movement speeds to what your + endstops can deal with. The higher the allowed acceleration ( = deceleration, + see #define ACCELERATION) and the more clearance the endstop comes with, + the faster Teacup will do homing movements. + + Set here how many micrometers (mm * 1000) your endstop allows the carriage + to overshoot the trigger point. Typically 1000 or 2000 for mechanical + endstops, more for optical ones. You can set it to zero, in which case + SEARCH_FEEDRATE_{XYZ} is used, but expect very slow homing movements. + + Units: micrometers + Sane values: 0 to 20000 (0 to 20 mm) + Valid range: 0 to 1000000 */ -// #define SLOW_HOMING +#define ENDSTOP_CLEARANCE_X 1000 +#define ENDSTOP_CLEARANCE_Y 1000 +#define ENDSTOP_CLEARANCE_Z 100 /** Soft axis limits, in mm. diff --git a/config.gen7-v1.1-v1.3.h b/config.gen7-v1.1-v1.3.h index 66c46cf..2aa1a47 100644 --- a/config.gen7-v1.1-v1.3.h +++ b/config.gen7-v1.1-v1.3.h @@ -90,17 +90,37 @@ #define MAXIMUM_FEEDRATE_Z 200 #define MAXIMUM_FEEDRATE_E 2000 -/// used when searching endstops and as default feedrate +/// Used when doing precision endstop search and as default feedrate. #define SEARCH_FEEDRATE_X 50 #define SEARCH_FEEDRATE_Y 50 #define SEARCH_FEEDRATE_Z 50 // no SEARCH_FEEDRATE_E, as E can't be searched -/** \def SLOW_HOMING - wether to search the home point slowly - With some endstop configurations, like when probing for the surface of a PCB, you can't deal with overrunning the endstop. In such a case, uncomment this definition. +/** \def ENDSTOP_CLEARANCE_X + \def ENDSTOP_CLEARANCE_Y + \def ENDSTOP_CLEARANCE_Z + + When hitting an endstop, Teacup properly decelerates instead of doing an + aprupt stop to save your mechanics. Ineviteably, this means it overshoots + the endstop trigger point by some distance. + + To deal with this, Teacup adapts homing movement speeds to what your + endstops can deal with. The higher the allowed acceleration ( = deceleration, + see #define ACCELERATION) and the more clearance the endstop comes with, + the faster Teacup will do homing movements. + + Set here how many micrometers (mm * 1000) your endstop allows the carriage + to overshoot the trigger point. Typically 1000 or 2000 for mechanical + endstops, more for optical ones. You can set it to zero, in which case + SEARCH_FEEDRATE_{XYZ} is used, but expect very slow homing movements. + + Units: micrometers + Sane values: 0 to 20000 (0 to 20 mm) + Valid range: 0 to 1000000 */ -// #define SLOW_HOMING +#define ENDSTOP_CLEARANCE_X 1000 +#define ENDSTOP_CLEARANCE_Y 1000 +#define ENDSTOP_CLEARANCE_Z 100 /** Soft axis limits, in mm. diff --git a/config.gen7-v1.4.h b/config.gen7-v1.4.h index 55b27ee..9a7f76f 100644 --- a/config.gen7-v1.4.h +++ b/config.gen7-v1.4.h @@ -90,17 +90,37 @@ #define MAXIMUM_FEEDRATE_Z 200 #define MAXIMUM_FEEDRATE_E 2000 -/// used when searching endstops and as default feedrate +/// Used when doing precision endstop search and as default feedrate. #define SEARCH_FEEDRATE_X 50 #define SEARCH_FEEDRATE_Y 50 #define SEARCH_FEEDRATE_Z 50 // no SEARCH_FEEDRATE_E, as E can't be searched -/** \def SLOW_HOMING - wether to search the home point slowly - With some endstop configurations, like when probing for the surface of a PCB, you can't deal with overrunning the endstop. In such a case, uncomment this definition. +/** \def ENDSTOP_CLEARANCE_X + \def ENDSTOP_CLEARANCE_Y + \def ENDSTOP_CLEARANCE_Z + + When hitting an endstop, Teacup properly decelerates instead of doing an + aprupt stop to save your mechanics. Ineviteably, this means it overshoots + the endstop trigger point by some distance. + + To deal with this, Teacup adapts homing movement speeds to what your + endstops can deal with. The higher the allowed acceleration ( = deceleration, + see #define ACCELERATION) and the more clearance the endstop comes with, + the faster Teacup will do homing movements. + + Set here how many micrometers (mm * 1000) your endstop allows the carriage + to overshoot the trigger point. Typically 1000 or 2000 for mechanical + endstops, more for optical ones. You can set it to zero, in which case + SEARCH_FEEDRATE_{XYZ} is used, but expect very slow homing movements. + + Units: micrometers + Sane values: 0 to 20000 (0 to 20 mm) + Valid range: 0 to 1000000 */ -// #define SLOW_HOMING +#define ENDSTOP_CLEARANCE_X 1000 +#define ENDSTOP_CLEARANCE_Y 1000 +#define ENDSTOP_CLEARANCE_Z 100 /** Soft axis limits, in mm. diff --git a/config.ramps-v1.2.h b/config.ramps-v1.2.h index ba9c682..86079e6 100644 --- a/config.ramps-v1.2.h +++ b/config.ramps-v1.2.h @@ -84,17 +84,37 @@ #define MAXIMUM_FEEDRATE_Z 100 #define MAXIMUM_FEEDRATE_E 600 -/// used when searching endstops and as default feedrate +/// Used when doing precision endstop search and as default feedrate. #define SEARCH_FEEDRATE_X 50 #define SEARCH_FEEDRATE_Y 50 #define SEARCH_FEEDRATE_Z 1 // no SEARCH_FEEDRATE_E, as E can't be searched -/** \def SLOW_HOMING - wether to search the home point slowly - With some endstop configurations, like when probing for the surface of a PCB, you can't deal with overrunning the endstop. In such a case, uncomment this definition. +/** \def ENDSTOP_CLEARANCE_X + \def ENDSTOP_CLEARANCE_Y + \def ENDSTOP_CLEARANCE_Z + + When hitting an endstop, Teacup properly decelerates instead of doing an + aprupt stop to save your mechanics. Ineviteably, this means it overshoots + the endstop trigger point by some distance. + + To deal with this, Teacup adapts homing movement speeds to what your + endstops can deal with. The higher the allowed acceleration ( = deceleration, + see #define ACCELERATION) and the more clearance the endstop comes with, + the faster Teacup will do homing movements. + + Set here how many micrometers (mm * 1000) your endstop allows the carriage + to overshoot the trigger point. Typically 1000 or 2000 for mechanical + endstops, more for optical ones. You can set it to zero, in which case + SEARCH_FEEDRATE_{XYZ} is used, but expect very slow homing movements. + + Units: micrometers + Sane values: 0 to 20000 (0 to 20 mm) + Valid range: 0 to 1000000 */ -// #define SLOW_HOMING +#define ENDSTOP_CLEARANCE_X 1000 +#define ENDSTOP_CLEARANCE_Y 1000 +#define ENDSTOP_CLEARANCE_Z 100 /** Soft axis limits, in mm diff --git a/config.ramps-v1.3.h b/config.ramps-v1.3.h index 9297585..ed74efe 100644 --- a/config.ramps-v1.3.h +++ b/config.ramps-v1.3.h @@ -84,17 +84,37 @@ #define MAXIMUM_FEEDRATE_Z 100 #define MAXIMUM_FEEDRATE_E 600 -/// used when searching endstops and as default feedrate +/// Used when doing precision endstop search and as default feedrate. #define SEARCH_FEEDRATE_X 50 #define SEARCH_FEEDRATE_Y 50 #define SEARCH_FEEDRATE_Z 1 // no SEARCH_FEEDRATE_E, as E can't be searched -/** \def SLOW_HOMING - wether to search the home point slowly - With some endstop configurations, like when probing for the surface of a PCB, you can't deal with overrunning the endstop. In such a case, uncomment this definition. +/** \def ENDSTOP_CLEARANCE_X + \def ENDSTOP_CLEARANCE_Y + \def ENDSTOP_CLEARANCE_Z + + When hitting an endstop, Teacup properly decelerates instead of doing an + aprupt stop to save your mechanics. Ineviteably, this means it overshoots + the endstop trigger point by some distance. + + To deal with this, Teacup adapts homing movement speeds to what your + endstops can deal with. The higher the allowed acceleration ( = deceleration, + see #define ACCELERATION) and the more clearance the endstop comes with, + the faster Teacup will do homing movements. + + Set here how many micrometers (mm * 1000) your endstop allows the carriage + to overshoot the trigger point. Typically 1000 or 2000 for mechanical + endstops, more for optical ones. You can set it to zero, in which case + SEARCH_FEEDRATE_{XYZ} is used, but expect very slow homing movements. + + Units: micrometers + Sane values: 0 to 20000 (0 to 20 mm) + Valid range: 0 to 1000000 */ -// #define SLOW_HOMING +#define ENDSTOP_CLEARANCE_X 1000 +#define ENDSTOP_CLEARANCE_Y 1000 +#define ENDSTOP_CLEARANCE_Z 100 /** Soft axis limits, in mm. diff --git a/config.sanguinololu-v1.1.h b/config.sanguinololu-v1.1.h index 719ea2c..9b859ac 100644 --- a/config.sanguinololu-v1.1.h +++ b/config.sanguinololu-v1.1.h @@ -83,17 +83,37 @@ #define MAXIMUM_FEEDRATE_Z 100 #define MAXIMUM_FEEDRATE_E 200 -/// used when searching endstops and as default feedrate +/// Used when doing precision endstop search and as default feedrate. #define SEARCH_FEEDRATE_X 50 #define SEARCH_FEEDRATE_Y 50 #define SEARCH_FEEDRATE_Z 50 // no SEARCH_FEEDRATE_E, as E can't be searched -/** \def SLOW_HOMING - wether to search the home point slowly - With some endstop configurations, like when probing for the surface of a PCB, you can't deal with overrunning the endstop. In such a case, uncomment this definition. +/** \def ENDSTOP_CLEARANCE_X + \def ENDSTOP_CLEARANCE_Y + \def ENDSTOP_CLEARANCE_Z + + When hitting an endstop, Teacup properly decelerates instead of doing an + aprupt stop to save your mechanics. Ineviteably, this means it overshoots + the endstop trigger point by some distance. + + To deal with this, Teacup adapts homing movement speeds to what your + endstops can deal with. The higher the allowed acceleration ( = deceleration, + see #define ACCELERATION) and the more clearance the endstop comes with, + the faster Teacup will do homing movements. + + Set here how many micrometers (mm * 1000) your endstop allows the carriage + to overshoot the trigger point. Typically 1000 or 2000 for mechanical + endstops, more for optical ones. You can set it to zero, in which case + SEARCH_FEEDRATE_{XYZ} is used, but expect very slow homing movements. + + Units: micrometers + Sane values: 0 to 20000 (0 to 20 mm) + Valid range: 0 to 1000000 */ -// #define SLOW_HOMING +#define ENDSTOP_CLEARANCE_X 1000 +#define ENDSTOP_CLEARANCE_Y 1000 +#define ENDSTOP_CLEARANCE_Z 100 /** Soft axis limits, in mm. diff --git a/config.sanguinololu-v1.2.h b/config.sanguinololu-v1.2.h index 5a039c8..c9d5478 100644 --- a/config.sanguinololu-v1.2.h +++ b/config.sanguinololu-v1.2.h @@ -83,17 +83,37 @@ #define MAXIMUM_FEEDRATE_Z 100 #define MAXIMUM_FEEDRATE_E 200 -/// used when searching endstops and as default feedrate +/// Used when doing precision endstop search and as default feedrate. #define SEARCH_FEEDRATE_X 50 #define SEARCH_FEEDRATE_Y 50 #define SEARCH_FEEDRATE_Z 50 // no SEARCH_FEEDRATE_E, as E can't be searched -/** \def SLOW_HOMING - wether to search the home point slowly - With some endstop configurations, like when probing for the surface of a PCB, you can't deal with overrunning the endstop. In such a case, uncomment this definition. +/** \def ENDSTOP_CLEARANCE_X + \def ENDSTOP_CLEARANCE_Y + \def ENDSTOP_CLEARANCE_Z + + When hitting an endstop, Teacup properly decelerates instead of doing an + aprupt stop to save your mechanics. Ineviteably, this means it overshoots + the endstop trigger point by some distance. + + To deal with this, Teacup adapts homing movement speeds to what your + endstops can deal with. The higher the allowed acceleration ( = deceleration, + see #define ACCELERATION) and the more clearance the endstop comes with, + the faster Teacup will do homing movements. + + Set here how many micrometers (mm * 1000) your endstop allows the carriage + to overshoot the trigger point. Typically 1000 or 2000 for mechanical + endstops, more for optical ones. You can set it to zero, in which case + SEARCH_FEEDRATE_{XYZ} is used, but expect very slow homing movements. + + Units: micrometers + Sane values: 0 to 20000 (0 to 20 mm) + Valid range: 0 to 1000000 */ -// #define SLOW_HOMING +#define ENDSTOP_CLEARANCE_X 1000 +#define ENDSTOP_CLEARANCE_Y 1000 +#define ENDSTOP_CLEARANCE_Z 100 /** Soft axis limits, in mm. diff --git a/config.sanguish.h b/config.sanguish.h index 985c458..6c5c8d4 100644 --- a/config.sanguish.h +++ b/config.sanguish.h @@ -90,17 +90,37 @@ #define MAXIMUM_FEEDRATE_Z 100 #define MAXIMUM_FEEDRATE_E 200 -/// used when searching endstops and as default feedrate +/// Used when doing precision endstop search and as default feedrate. #define SEARCH_FEEDRATE_X 50 #define SEARCH_FEEDRATE_Y 50 #define SEARCH_FEEDRATE_Z 50 // no SEARCH_FEEDRATE_E, as E can't be searched -/** \def SLOW_HOMING - wether to search the home point slowly - With some endstop configurations, like when probing for the surface of a PCB, you can't deal with overrunning the endstop. In such a case, uncomment this definition. +/** \def ENDSTOP_CLEARANCE_X + \def ENDSTOP_CLEARANCE_Y + \def ENDSTOP_CLEARANCE_Z + + When hitting an endstop, Teacup properly decelerates instead of doing an + aprupt stop to save your mechanics. Ineviteably, this means it overshoots + the endstop trigger point by some distance. + + To deal with this, Teacup adapts homing movement speeds to what your + endstops can deal with. The higher the allowed acceleration ( = deceleration, + see #define ACCELERATION) and the more clearance the endstop comes with, + the faster Teacup will do homing movements. + + Set here how many micrometers (mm * 1000) your endstop allows the carriage + to overshoot the trigger point. Typically 1000 or 2000 for mechanical + endstops, more for optical ones. You can set it to zero, in which case + SEARCH_FEEDRATE_{XYZ} is used, but expect very slow homing movements. + + Units: micrometers + Sane values: 0 to 20000 (0 to 20 mm) + Valid range: 0 to 1000000 */ -// #define SLOW_HOMING +#define ENDSTOP_CLEARANCE_X 1000 +#define ENDSTOP_CLEARANCE_Y 1000 +#define ENDSTOP_CLEARANCE_Z 100 /** Soft axis limits, in mm. diff --git a/config.teensy.h b/config.teensy.h index 1b22663..9165adf 100644 --- a/config.teensy.h +++ b/config.teensy.h @@ -97,17 +97,37 @@ MXL 2.032 mm/tooth, 29 #define MAXIMUM_FEEDRATE_Z 233 #define MAXIMUM_FEEDRATE_E 680 -/// used when searching endstops and as default feedrate +/// Used when doing precision endstop search and as default feedrate. #define SEARCH_FEEDRATE_X 50 #define SEARCH_FEEDRATE_Y 50 #define SEARCH_FEEDRATE_Z 50 // no SEARCH_FEEDRATE_E, as E can't be searched -/** \def SLOW_HOMING - wether to search the home point slowly - With some endstop configurations, like when probing for the surface of a PCB, you can't deal with overrunning the endstop. In such a case, uncomment this definition. +/** \def ENDSTOP_CLEARANCE_X + \def ENDSTOP_CLEARANCE_Y + \def ENDSTOP_CLEARANCE_Z + + When hitting an endstop, Teacup properly decelerates instead of doing an + aprupt stop to save your mechanics. Ineviteably, this means it overshoots + the endstop trigger point by some distance. + + To deal with this, Teacup adapts homing movement speeds to what your + endstops can deal with. The higher the allowed acceleration ( = deceleration, + see #define ACCELERATION) and the more clearance the endstop comes with, + the faster Teacup will do homing movements. + + Set here how many micrometers (mm * 1000) your endstop allows the carriage + to overshoot the trigger point. Typically 1000 or 2000 for mechanical + endstops, more for optical ones. You can set it to zero, in which case + SEARCH_FEEDRATE_{XYZ} is used, but expect very slow homing movements. + + Units: micrometers + Sane values: 0 to 20000 (0 to 20 mm) + Valid range: 0 to 1000000 */ -// #define SLOW_HOMING +#define ENDSTOP_CLEARANCE_X 1000 +#define ENDSTOP_CLEARANCE_Y 1000 +#define ENDSTOP_CLEARANCE_Z 100 /** Soft axis limits, in mm. diff --git a/config.teensypp.h b/config.teensypp.h index 3620754..31ce8f8 100644 --- a/config.teensypp.h +++ b/config.teensypp.h @@ -98,17 +98,37 @@ GT2 2.000 mm/tooth, 20 teeth #define MAXIMUM_FEEDRATE_Z 233 #define MAXIMUM_FEEDRATE_E 680 -/// used when searching endstops and as default feedrate +/// Used when doing precision endstop search and as default feedrate. #define SEARCH_FEEDRATE_X 50 #define SEARCH_FEEDRATE_Y 50 #define SEARCH_FEEDRATE_Z 50 // no SEARCH_FEEDRATE_E, as E can't be searched -/** \def SLOW_HOMING - wether to search the home point slowly - With some endstop configurations, like when probing for the surface of a PCB, you can't deal with overrunning the endstop. In such a case, uncomment this definition. +/** \def ENDSTOP_CLEARANCE_X + \def ENDSTOP_CLEARANCE_Y + \def ENDSTOP_CLEARANCE_Z + + When hitting an endstop, Teacup properly decelerates instead of doing an + aprupt stop to save your mechanics. Ineviteably, this means it overshoots + the endstop trigger point by some distance. + + To deal with this, Teacup adapts homing movement speeds to what your + endstops can deal with. The higher the allowed acceleration ( = deceleration, + see #define ACCELERATION) and the more clearance the endstop comes with, + the faster Teacup will do homing movements. + + Set here how many micrometers (mm * 1000) your endstop allows the carriage + to overshoot the trigger point. Typically 1000 or 2000 for mechanical + endstops, more for optical ones. You can set it to zero, in which case + SEARCH_FEEDRATE_{XYZ} is used, but expect very slow homing movements. + + Units: micrometers + Sane values: 0 to 20000 (0 to 20 mm) + Valid range: 0 to 1000000 */ -// #define SLOW_HOMING +#define ENDSTOP_CLEARANCE_X 1000 +#define ENDSTOP_CLEARANCE_Y 1000 +#define ENDSTOP_CLEARANCE_Z 100 /** Soft axis limits, in mm.