config.h

00001 /*
00002   config.h - compile time configuration
00003   Part of Grbl
00004 
00005   Copyright (c) 2012-2016 Sungeun K. Jeon for Gnea Research LLC
00006   Copyright (c) 2009-2011 Simen Svale Skogsrud
00007 
00008   Grbl is free software: you can redistribute it and/or modify
00009   it under the terms of the GNU General Public License as published by
00010   the Free Software Foundation, either version 3 of the License, or
00011   (at your option) any later version.
00012 
00013   Grbl is distributed in the hope that it will be useful,
00014   but WITHOUT ANY WARRANTY; without even the implied warranty of
00015   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016   GNU General Public License for more details.
00017 
00018   You should have received a copy of the GNU General Public License
00019   along with Grbl.  If not, see <http://www.gnu.org/licenses/>.
00020 */
00021 
00022 // This file contains compile-time configurations for Grbl's internal system. For the most part,
00023 // users will not need to directly modify these, but they are here for specific needs, i.e.
00024 // performance tuning or adjusting to non-typical machines.
00025 
00026 // IMPORTANT: Any changes here requires a full re-compiling of the source code to propagate them.
00027 
00028 #ifndef config_h
00029 #define config_h
00030 #include "grbl.h" // For Arduino IDE compatibility.
00031 
00032 
00033 // Define CPU pin map and default settings.
00034 // NOTE: OEMs can avoid the need to maintain/update the defaults.h and cpu_map.h files and use only
00035 // one configuration file by placing their specific defaults and pin map at the bottom of this file.
00036 // If doing so, simply comment out these two defines and see instructions below.
00037 //#define DEFAULTS_GENERIC
00038 #define DEFAULT_CNC3020
00039 #ifdef WIN32
00040 #define CPU_MAP_WIN32
00041 #endif
00042 #ifdef AVRTARGET
00043 #define CPU_MAP_ATMEGA328P // Arduino Uno CPU
00044 #endif
00045 #ifdef STM32F103C8
00046 #define CPU_MAP_STM32F103
00047 #endif
00048 
00049 // Serial baud rate
00050 // #define BAUD_RATE 230400
00051 #define BAUD_RATE 115200
00052 
00053 // Define realtime command special characters. These characters are 'picked-off' directly from the
00054 // serial read data stream and are not passed to the grbl line execution parser. Select characters
00055 // that do not and must not exist in the streamed g-code program. ASCII control characters may be
00056 // used, if they are available per user setup. Also, extended ASCII codes (>127), which are never in
00057 // g-code programs, maybe selected for interface programs.
00058 // NOTE: If changed, manually update help message in report.c.
00059 
00060 #define CMD_RESET 0x18 // ctrl-x.
00061 #define CMD_STATUS_REPORT '?'
00062 #define CMD_CYCLE_START '~'
00063 #define CMD_FEED_HOLD '!'
00064 
00065 // NOTE: All override realtime commands must be in the extended ASCII character set, starting
00066 // at character value 128 (0x80) and up to 255 (0xFF). If the normal set of realtime commands,
00067 // such as status reports, feed hold, reset, and cycle start, are moved to the extended set
00068 // space, serial.c's RX ISR will need to be modified to accomodate the change.
00069 // #define CMD_RESET 0x80
00070 // #define CMD_STATUS_REPORT 0x81
00071 // #define CMD_CYCLE_START 0x82
00072 // #define CMD_FEED_HOLD 0x83
00073 #define CMD_SAFETY_DOOR 0x84
00074 #define CMD_JOG_CANCEL  0x85
00075 #define CMD_DEBUG_REPORT 0x86 // Only when DEBUG enabled, sends debug report in '{}' braces.
00076 #define CMD_FEED_OVR_RESET 0x90         // Restores feed override value to 100%.
00077 #define CMD_FEED_OVR_COARSE_PLUS 0x91
00078 #define CMD_FEED_OVR_COARSE_MINUS 0x92
00079 #define CMD_FEED_OVR_FINE_PLUS  0x93
00080 #define CMD_FEED_OVR_FINE_MINUS  0x94
00081 #define CMD_RAPID_OVR_RESET 0x95        // Restores rapid override value to 100%.
00082 #define CMD_RAPID_OVR_MEDIUM 0x96
00083 #define CMD_RAPID_OVR_LOW 0x97
00084 // #define CMD_RAPID_OVR_EXTRA_LOW 0x98 // *NOT SUPPORTED*
00085 #define CMD_SPINDLE_OVR_RESET 0x99      // Restores spindle override value to 100%.
00086 #define CMD_SPINDLE_OVR_COARSE_PLUS 0x9A
00087 #define CMD_SPINDLE_OVR_COARSE_MINUS 0x9B
00088 #define CMD_SPINDLE_OVR_FINE_PLUS 0x9C
00089 #define CMD_SPINDLE_OVR_FINE_MINUS 0x9D
00090 #define CMD_SPINDLE_OVR_STOP 0x9E
00091 #define CMD_COOLANT_FLOOD_OVR_TOGGLE 0xA0
00092 #define CMD_COOLANT_MIST_OVR_TOGGLE 0xA1
00093 
00094 // If homing is enabled, homing init lock sets Grbl into an alarm state upon power up. This forces
00095 // the user to perform the homing cycle (or override the locks) before doing anything else. This is
00096 // mainly a safety feature to remind the user to home, since position is unknown to Grbl.
00097 #define HOMING_INIT_LOCK // Comment to disable
00098 
00099 // Define the homing cycle patterns with bitmasks. The homing cycle first performs a search mode
00100 // to quickly engage the limit switches, followed by a slower locate mode, and finished by a short
00101 // pull-off motion to disengage the limit switches. The following HOMING_CYCLE_x defines are executed
00102 // in order starting with suffix 0 and completes the homing routine for the specified-axes only. If
00103 // an axis is omitted from the defines, it will not home, nor will the system update its position.
00104 // Meaning that this allows for users with non-standard cartesian machines, such as a lathe (x then z,
00105 // with no y), to configure the homing cycle behavior to their needs.
00106 // NOTE: The homing cycle is designed to allow sharing of limit pins, if the axes are not in the same
00107 // cycle, but this requires some pin settings changes in cpu_map.h file. For example, the default homing
00108 // cycle can share the Z limit pin with either X or Y limit pins, since they are on different cycles.
00109 // By sharing a pin, this frees up a precious IO pin for other purposes. In theory, all axes limit pins
00110 // may be reduced to one pin, if all axes are homed with seperate cycles, or vice versa, all three axes
00111 // on separate pin, but homed in one cycle. Also, it should be noted that the function of hard limits
00112 // will not be affected by pin sharing.
00113 // NOTE: Defaults are set for a traditional 3-axis CNC machine. Z-axis first to clear, followed by X & Y.
00114 #define HOMING_CYCLE_0 (1<<Z_AXIS)                // REQUIRED: First move Z to clear workspace.
00115 #define HOMING_CYCLE_1 ((1<<X_AXIS)|(1<<Y_AXIS))  // OPTIONAL: Then move X,Y at the same time.
00116 // #define HOMING_CYCLE_2                         // OPTIONAL: Uncomment and add axes mask to enable
00117 
00118 // NOTE: The following are two examples to setup homing for 2-axis machines.
00119 // #define HOMING_CYCLE_0 ((1<<X_AXIS)|(1<<Y_AXIS))  // NOT COMPATIBLE WITH COREXY: Homes both X-Y in one cycle. 
00120 
00121 // #define HOMING_CYCLE_0 (1<<X_AXIS)  // COREXY COMPATIBLE: First home X
00122 // #define HOMING_CYCLE_1 (1<<Y_AXIS)  // COREXY COMPATIBLE: Then home Y
00123 
00124 // Number of homing cycles performed after when the machine initially jogs to limit switches.
00125 // This help in preventing overshoot and should improve repeatability. This value should be one or
00126 // greater.
00127 #define N_HOMING_LOCATE_CYCLE 1 // Integer (1-128)
00128 
00129 // Enables single axis homing commands. $HX, $HY, and $HZ for X, Y, and Z-axis homing. The full homing 
00130 // cycle is still invoked by the $H command. This is disabled by default. It's here only to address
00131 // users that need to switch between a two-axis and three-axis machine. This is actually very rare.
00132 // If you have a two-axis machine, DON'T USE THIS. Instead, just alter the homing cycle for two-axes.
00133 // #define HOMING_SINGLE_AXIS_COMMANDS // Default disabled. Uncomment to enable.
00134 
00135 // After homing, Grbl will set by default the entire machine space into negative space, as is typical
00136 // for professional CNC machines, regardless of where the limit switches are located. Uncomment this
00137 // define to force Grbl to always set the machine origin at the homed location despite switch orientation.
00138 // #define HOMING_FORCE_SET_ORIGIN // Uncomment to enable.
00139 
00140 // Number of blocks Grbl executes upon startup. These blocks are stored in EEPROM, where the size
00141 // and addresses are defined in settings.h. With the current settings, up to 2 startup blocks may
00142 // be stored and executed in order. These startup blocks would typically be used to set the g-code
00143 // parser state depending on user preferences.
00144 #define N_STARTUP_LINE 2 // Integer (1-2)
00145 
00146 // Number of floating decimal points printed by Grbl for certain value types. These settings are
00147 // determined by realistic and commonly observed values in CNC machines. For example, position
00148 // values cannot be less than 0.001mm or 0.0001in, because machines can not be physically more
00149 // precise this. So, there is likely no need to change these, but you can if you need to here.
00150 // NOTE: Must be an integer value from 0 to ~4. More than 4 may exhibit round-off errors.
00151 #define N_DECIMAL_COORDVALUE_INCH 4 // Coordinate or position value in inches
00152 #define N_DECIMAL_COORDVALUE_MM   3 // Coordinate or position value in mm
00153 #define N_DECIMAL_RATEVALUE_INCH  1 // Rate or velocity value in in/min
00154 #define N_DECIMAL_RATEVALUE_MM    0 // Rate or velocity value in mm/min
00155 #define N_DECIMAL_SETTINGVALUE    3 // Decimals for floating point setting values
00156 #define N_DECIMAL_RPMVALUE        0 // RPM value in rotations per min.
00157 
00158 // If your machine has two limits switches wired in parallel to one axis, you will need to enable
00159 // this feature. Since the two switches are sharing a single pin, there is no way for Grbl to tell
00160 // which one is enabled. This option only effects homing, where if a limit is engaged, Grbl will
00161 // alarm out and force the user to manually disengage the limit switch. Otherwise, if you have one
00162 // limit switch for each axis, don't enable this option. By keeping it disabled, you can perform a
00163 // homing cycle while on the limit switch and not have to move the machine off of it.
00164 // #define LIMITS_TWO_SWITCHES_ON_AXES
00165 
00166 // Allows GRBL to track and report gcode line numbers.  Enabling this means that the planning buffer
00167 // goes from 16 to 15 to make room for the additional line number data in the plan_block_t struct
00168 // #define USE_LINE_NUMBERS // Disabled by default. Uncomment to enable.
00169 
00170 // Upon a successful probe cycle, this option provides immediately feedback of the probe coordinates
00171 // through an automatically generated message. If disabled, users can still access the last probe
00172 // coordinates through Grbl '$#' print parameters.
00173 #define MESSAGE_PROBE_COORDINATES // Enabled by default. Comment to disable.
00174 
00175 // Enables a second coolant control pin via the mist coolant g-code command M7 on the Arduino Uno
00176 // analog pin 4. Only use this option if you require a second coolant control pin.
00177 // NOTE: The M8 flood coolant control pin on analog pin 3 will still be functional regardless.
00178 // #define ENABLE_M7 // Disabled by default. Uncomment to enable.
00179 
00180 // This option causes the feed hold input to act as a safety door switch. A safety door, when triggered,
00181 // immediately forces a feed hold and then safely de-energizes the machine. Resuming is blocked until
00182 // the safety door is re-engaged. When it is, Grbl will re-energize the machine and then resume on the
00183 // previous tool path, as if nothing happened.
00184 // #define ENABLE_SAFETY_DOOR_INPUT_PIN // Default disabled. Uncomment to enable.
00185 
00186 // After the safety door switch has been toggled and restored, this setting sets the power-up delay
00187 // between restoring the spindle and coolant and resuming the cycle.
00188 #define SAFETY_DOOR_SPINDLE_DELAY 4.0 // Float (seconds)
00189 #define SAFETY_DOOR_COOLANT_DELAY 1.0 // Float (seconds)
00190 
00191 // Enable CoreXY kinematics. Use ONLY with CoreXY machines.
00192 // IMPORTANT: If homing is enabled, you must reconfigure the homing cycle #defines above to
00193 // #define HOMING_CYCLE_0 (1<<X_AXIS) and #define HOMING_CYCLE_1 (1<<Y_AXIS)
00194 // NOTE: This configuration option alters the motion of the X and Y axes to principle of operation
00195 // defined at (http://corexy.com/theory.html). Motors are assumed to positioned and wired exactly as
00196 // described, if not, motions may move in strange directions. Grbl requires the CoreXY A and B motors
00197 // have the same steps per mm internally.
00198 // #define COREXY // Default disabled. Uncomment to enable.
00199 
00200 // Inverts pin logic of the control command pins based on a mask. This essentially means you can use
00201 // normally-closed switches on the specified pins, rather than the default normally-open switches.
00202 // NOTE: The top option will mask and invert all control pins. The bottom option is an example of
00203 // inverting only two control pins, the safety door and reset. See cpu_map.h for other bit definitions.
00204 // #define INVERT_CONTROL_PIN_MASK CONTROL_MASK // Default disabled. Uncomment to disable.
00205 // #define INVERT_CONTROL_PIN_MASK ((1<<CONTROL_SAFETY_DOOR_BIT)|(CONTROL_RESET_BIT)) // Default disabled.
00206 
00207 // Inverts select limit pin states based on the following mask. This effects all limit pin functions,
00208 // such as hard limits and homing. However, this is different from overall invert limits setting.
00209 // This build option will invert only the limit pins defined here, and then the invert limits setting
00210 // will be applied to all of them. This is useful when a user has a mixed set of limit pins with both
00211 // normally-open(NO) and normally-closed(NC) switches installed on their machine.
00212 // NOTE: PLEASE DO NOT USE THIS, unless you have a situation that needs it.
00213 // #define INVERT_LIMIT_PIN_MASK ((1<<X_LIMIT_BIT)|(1<<Y_LIMIT_BIT)) // Default disabled. Uncomment to enable.
00214 
00215 // Inverts the spindle enable pin from low-disabled/high-enabled to low-enabled/high-disabled. Useful
00216 // for some pre-built electronic boards.
00217 // NOTE: If VARIABLE_SPINDLE is enabled(default), this option has no effect as the PWM output and
00218 // spindle enable are combined to one pin. If you need both this option and spindle speed PWM,
00219 // uncomment the config option USE_SPINDLE_DIR_AS_ENABLE_PIN below.
00220 // #define INVERT_SPINDLE_ENABLE_PIN // Default disabled. Uncomment to enable.
00221 
00222 // Inverts the selected coolant pin from low-disabled/high-enabled to low-enabled/high-disabled. Useful
00223 // for some pre-built electronic boards.
00224 // #define INVERT_COOLANT_FLOOD_PIN // Default disabled. Uncomment to enable.
00225 // #define INVERT_COOLANT_MIST_PIN // Default disabled. Note: Enable M7 mist coolant in config.h
00226 
00227 // When Grbl powers-cycles or is hard reset with the Arduino reset button, Grbl boots up with no ALARM
00228 // by default. This is to make it as simple as possible for new users to start using Grbl. When homing
00229 // is enabled and a user has installed limit switches, Grbl will boot up in an ALARM state to indicate
00230 // Grbl doesn't know its position and to force the user to home before proceeding. This option forces
00231 // Grbl to always initialize into an ALARM state regardless of homing or not. This option is more for
00232 // OEMs and LinuxCNC users that would like this power-cycle behavior.
00233 // #define FORCE_INITIALIZATION_ALARM // Default disabled. Uncomment to enable.
00234 
00235 // At power-up or a reset, Grbl will check the limit switch states to ensure they are not active
00236 // before initialization. If it detects a problem and the hard limits setting is enabled, Grbl will
00237 // simply message the user to check the limits and enter an alarm state, rather than idle. Grbl will
00238 // not throw an alarm message.
00239 #define CHECK_LIMITS_AT_INIT
00240 
00241 // ---------------------------------------------------------------------------------------
00242 // ADVANCED CONFIGURATION OPTIONS:
00243 
00244 // Enables code for debugging purposes. Not for general use and always in constant flux.
00245 // #define DEBUG // Uncomment to enable. Default disabled.
00246 
00247 // Configure rapid, feed, and spindle override settings. These values define the max and min
00248 // allowable override values and the coarse and fine increments per command received. Please
00249 // note the allowable values in the descriptions following each define.
00250 #define DEFAULT_FEED_OVERRIDE           100 // 100%. Don't change this value.
00251 #define MAX_FEED_RATE_OVERRIDE          200 // Percent of programmed feed rate (100-255). Usually 120% or 200%
00252 #define MIN_FEED_RATE_OVERRIDE           10 // Percent of programmed feed rate (1-100). Usually 50% or 1%
00253 #define FEED_OVERRIDE_COARSE_INCREMENT   10 // (1-99). Usually 10%.
00254 #define FEED_OVERRIDE_FINE_INCREMENT      1 // (1-99). Usually 1%.
00255 
00256 #define DEFAULT_RAPID_OVERRIDE  100 // 100%. Don't change this value.
00257 #define RAPID_OVERRIDE_MEDIUM    50 // Percent of rapid (1-99). Usually 50%.
00258 #define RAPID_OVERRIDE_LOW       25 // Percent of rapid (1-99). Usually 25%.
00259 // #define RAPID_OVERRIDE_EXTRA_LOW 5 // *NOT SUPPORTED* Percent of rapid (1-99). Usually 5%.
00260 
00261 #define DEFAULT_SPINDLE_SPEED_OVERRIDE    100 // 100%. Don't change this value.
00262 #define MAX_SPINDLE_SPEED_OVERRIDE        200 // Percent of programmed spindle speed (100-255). Usually 200%.
00263 #define MIN_SPINDLE_SPEED_OVERRIDE         10 // Percent of programmed spindle speed (1-100). Usually 10%.
00264 #define SPINDLE_OVERRIDE_COARSE_INCREMENT  10 // (1-99). Usually 10%.
00265 #define SPINDLE_OVERRIDE_FINE_INCREMENT     1 // (1-99). Usually 1%.
00266 
00267 // When a M2 or M30 program end command is executed, most g-code states are restored to their defaults.
00268 // This compile-time option includes the restoring of the feed, rapid, and spindle speed override values
00269 // to their default values at program end.
00270 #define RESTORE_OVERRIDES_AFTER_PROGRAM_END // Default enabled. Comment to disable.
00271 
00272 // The status report change for Grbl v1.1 and after also removed the ability to disable/enable most data
00273 // fields from the report. This caused issues for GUI developers, who've had to manage several scenarios
00274 // and configurations. The increased efficiency of the new reporting style allows for all data fields to 
00275 // be sent without potential performance issues.
00276 // NOTE: The options below are here only provide a way to disable certain data fields if a unique
00277 // situation demands it, but be aware GUIs may depend on this data. If disabled, it may not be compatible.
00278 #define REPORT_FIELD_BUFFER_STATE // Default enabled. Comment to disable.
00279 #define REPORT_FIELD_PIN_STATE // Default enabled. Comment to disable.
00280 #define REPORT_FIELD_CURRENT_FEED_SPEED // Default enabled. Comment to disable.
00281 #define REPORT_FIELD_WORK_COORD_OFFSET // Default enabled. Comment to disable.
00282 #define REPORT_FIELD_OVERRIDES // Default enabled. Comment to disable.
00283 #define REPORT_FIELD_LINE_NUMBERS // Default enabled. Comment to disable.
00284 
00285 // Some status report data isn't necessary for realtime, only intermittently, because the values don't
00286 // change often. The following macros configures how many times a status report needs to be called before
00287 // the associated data is refreshed and included in the status report. However, if one of these value
00288 // changes, Grbl will automatically include this data in the next status report, regardless of what the
00289 // count is at the time. This helps reduce the communication overhead involved with high frequency reporting
00290 // and agressive streaming. There is also a busy and an idle refresh count, which sets up Grbl to send
00291 // refreshes more often when its not doing anything important. With a good GUI, this data doesn't need
00292 // to be refreshed very often, on the order of a several seconds.
00293 // NOTE: WCO refresh must be 2 or greater. OVR refresh must be 1 or greater.
00294 #define REPORT_OVR_REFRESH_BUSY_COUNT 20  // (1-255)
00295 #define REPORT_OVR_REFRESH_IDLE_COUNT 10  // (1-255) Must be less than or equal to the busy count
00296 #define REPORT_WCO_REFRESH_BUSY_COUNT 30  // (2-255)
00297 #define REPORT_WCO_REFRESH_IDLE_COUNT 10  // (2-255) Must be less than or equal to the busy count
00298 
00299 // The temporal resolution of the acceleration management subsystem. A higher number gives smoother
00300 // acceleration, particularly noticeable on machines that run at very high feedrates, but may negatively
00301 // impact performance. The correct value for this parameter is machine dependent, so it's advised to
00302 // set this only as high as needed. Approximate successful values can widely range from 50 to 200 or more.
00303 // NOTE: Changing this value also changes the execution time of a segment in the step segment buffer.
00304 // When increasing this value, this stores less overall time in the segment buffer and vice versa. Make
00305 // certain the step segment buffer is increased/decreased to account for these changes.
00306 #define ACCELERATION_TICKS_PER_SECOND 100
00307 
00308 // Adaptive Multi-Axis Step Smoothing (AMASS) is an advanced feature that does what its name implies,
00309 // smoothing the stepping of multi-axis motions. This feature smooths motion particularly at low step
00310 // frequencies below 10kHz, where the aliasing between axes of multi-axis motions can cause audible
00311 // noise and shake your machine. At even lower step frequencies, AMASS adapts and provides even better
00312 // step smoothing. See stepper.c for more details on the AMASS system works.
00313 #define ADAPTIVE_MULTI_AXIS_STEP_SMOOTHING  // Default enabled. Comment to disable.
00314 
00315 // Sets the maximum step rate allowed to be written as a Grbl setting. This option enables an error
00316 // check in the settings module to prevent settings values that will exceed this limitation. The maximum
00317 // step rate is strictly limited by the CPU speed and will change if something other than an AVR running
00318 // at 16MHz is used.
00319 // NOTE: For now disabled, will enable if flash space permits.
00320 // #define MAX_STEP_RATE_HZ 30000 // Hz
00321 
00322 // By default, Grbl sets all input pins to normal-high operation with their internal pull-up resistors
00323 // enabled. This simplifies the wiring for users by requiring only a switch connected to ground,
00324 // although its recommended that users take the extra step of wiring in low-pass filter to reduce
00325 // electrical noise detected by the pin. If the user inverts the pin in Grbl settings, this just flips
00326 // which high or low reading indicates an active signal. In normal operation, this means the user
00327 // needs to connect a normal-open switch, but if inverted, this means the user should connect a
00328 // normal-closed switch.
00329 // The following options disable the internal pull-up resistors, sets the pins to a normal-low
00330 // operation, and switches must be now connect to Vcc instead of ground. This also flips the meaning
00331 // of the invert pin Grbl setting, where an inverted setting now means the user should connect a
00332 // normal-open switch and vice versa.
00333 // NOTE: All pins associated with the feature are disabled, i.e. XYZ limit pins, not individual axes.
00334 // WARNING: When the pull-ups are disabled, this requires additional wiring with pull-down resistors!
00335 //#define DISABLE_LIMIT_PIN_PULL_UP
00336 //#define DISABLE_PROBE_PIN_PULL_UP
00337 //#define DISABLE_CONTROL_PIN_PULL_UP
00338 
00339 // Sets which axis the tool length offset is applied. Assumes the spindle is always parallel with
00340 // the selected axis with the tool oriented toward the negative direction. In other words, a positive
00341 // tool length offset value is subtracted from the current location.
00342 #define TOOL_LENGTH_OFFSET_AXIS Z_AXIS // Default z-axis. Valid values are X_AXIS, Y_AXIS, or Z_AXIS.
00343 
00344 // Enables variable spindle output voltage for different RPM values. On the Arduino Uno, the spindle
00345 // enable pin will output 5V for maximum RPM with 256 intermediate levels and 0V when disabled.
00346 // NOTE: IMPORTANT for Arduino Unos! When enabled, the Z-limit pin D11 and spindle enable pin D12 switch!
00347 // The hardware PWM output on pin D11 is required for variable spindle output voltages.
00348 #define VARIABLE_SPINDLE // Default enabled. Comment to disable.
00349 
00350 // Used by variable spindle output only. This forces the PWM output to a minimum duty cycle when enabled.
00351 // The PWM pin will still read 0V when the spindle is disabled. Most users will not need this option, but
00352 // it may be useful in certain scenarios. This minimum PWM settings coincides with the spindle rpm minimum
00353 // setting, like rpm max to max PWM. This is handy if you need a larger voltage difference between 0V disabled
00354 // and the voltage set by the minimum PWM for minimum rpm. This difference is 0.02V per PWM value. So, when
00355 // minimum PWM is at 1, only 0.02 volts separate enabled and disabled. At PWM 5, this would be 0.1V. Keep
00356 // in mind that you will begin to lose PWM resolution with increased minimum PWM values, since you have less
00357 // and less range over the total 255 PWM levels to signal different spindle speeds.
00358 // NOTE: Compute duty cycle at the minimum PWM by this equation: (% duty cycle)=(SPINDLE_PWM_MIN_VALUE/255)*100
00359 // #define SPINDLE_PWM_MIN_VALUE 5 // Default disabled. Uncomment to enable. Must be greater than zero. Integer (1-255).
00360 
00361 // By default on a 328p(Uno), Grbl combines the variable spindle PWM and the enable into one pin to help
00362 // preserve I/O pins. For certain setups, these may need to be separate pins. This configure option uses
00363 // the spindle direction pin(D13) as a separate spindle enable pin along with spindle speed PWM on pin D11.
00364 // NOTE: This configure option only works with VARIABLE_SPINDLE enabled and a 328p processor (Uno).
00365 // NOTE: Without a direction pin, M4 will not have a pin output to indicate a difference with M3. 
00366 // NOTE: BEWARE! The Arduino bootloader toggles the D13 pin when it powers up. If you flash Grbl with
00367 // a programmer (you can use a spare Arduino as "Arduino as ISP". Search the web on how to wire this.),
00368 // this D13 LED toggling should go away. We haven't tested this though. Please report how it goes!
00369 // #define USE_SPINDLE_DIR_AS_ENABLE_PIN // Default disabled. Uncomment to enable.
00370 
00371 // Alters the behavior of the spindle enable pin with the USE_SPINDLE_DIR_AS_ENABLE_PIN option . By default,
00372 // Grbl will not disable the enable pin if spindle speed is zero and M3/4 is active, but still sets the PWM 
00373 // output to zero. This allows the users to know if the spindle is active and use it as an additional control
00374 // input. However, in some use cases, user may want the enable pin to disable with a zero spindle speed and 
00375 // re-enable when spindle speed is greater than zero. This option does that.
00376 // NOTE: Requires USE_SPINDLE_DIR_AS_ENABLE_PIN to be enabled.
00377 // #define SPINDLE_ENABLE_OFF_WITH_ZERO_SPEED // Default disabled. Uncomment to enable.
00378 
00379 // With this enabled, Grbl sends back an echo of the line it has received, which has been pre-parsed (spaces
00380 // removed, capitalized letters, no comments) and is to be immediately executed by Grbl. Echoes will not be
00381 // sent upon a line buffer overflow, but should for all normal lines sent to Grbl. For example, if a user
00382 // sendss the line 'g1 x1.032 y2.45 (test comment)', Grbl will echo back in the form '[echo: G1X1.032Y2.45]'.
00383 // NOTE: Only use this for debugging purposes!! When echoing, this takes up valuable resources and can effect
00384 // performance. If absolutely needed for normal operation, the serial write buffer should be greatly increased
00385 // to help minimize transmission waiting within the serial write protocol.
00386 // #define REPORT_ECHO_LINE_RECEIVED // Default disabled. Uncomment to enable.
00387 
00388 // Minimum planner junction speed. Sets the default minimum junction speed the planner plans to at
00389 // every buffer block junction, except for starting from rest and end of the buffer, which are always
00390 // zero. This value controls how fast the machine moves through junctions with no regard for acceleration
00391 // limits or angle between neighboring block line move directions. This is useful for machines that can't
00392 // tolerate the tool dwelling for a split second, i.e. 3d printers or laser cutters. If used, this value
00393 // should not be much greater than zero or to the minimum value necessary for the machine to work.
00394 #define MINIMUM_JUNCTION_SPEED 0.0f // (mm/min)
00395 
00396 // Sets the minimum feed rate the planner will allow. Any value below it will be set to this minimum
00397 // value. This also ensures that a planned motion always completes and accounts for any floating-point
00398 // round-off errors. Although not recommended, a lower value than 1.0 mm/min will likely work in smaller
00399 // machines, perhaps to 0.1mm/min, but your success may vary based on multiple factors.
00400 #define MINIMUM_FEED_RATE 1.0 // (mm/min)
00401 
00402 // Number of arc generation iterations by small angle approximation before exact arc trajectory
00403 // correction with expensive sin() and cos() calcualtions. This parameter maybe decreased if there
00404 // are issues with the accuracy of the arc generations, or increased if arc execution is getting
00405 // bogged down by too many trig calculations.
00406 #define N_ARC_CORRECTION 12 // Integer (1-255)
00407 
00408 // The arc G2/3 g-code standard is problematic by definition. Radius-based arcs have horrible numerical
00409 // errors when arc at semi-circles(pi) or full-circles(2*pi). Offset-based arcs are much more accurate
00410 // but still have a problem when arcs are full-circles (2*pi). This define accounts for the floating
00411 // point issues when offset-based arcs are commanded as full circles, but get interpreted as extremely
00412 // small arcs with around machine epsilon (1.2e-7rad) due to numerical round-off and precision issues.
00413 // This define value sets the machine epsilon cutoff to determine if the arc is a full-circle or not.
00414 // NOTE: Be very careful when adjusting this value. It should always be greater than 1.2e-7 but not too
00415 // much greater than this. The default setting should capture most, if not all, full arc error situations.
00416 #define ARC_ANGULAR_TRAVEL_EPSILON 5E-7 // Float (radians)
00417 
00418 // Time delay increments performed during a dwell. The default value is set at 50ms, which provides
00419 // a maximum time delay of roughly 55 minutes, more than enough for most any application. Increasing
00420 // this delay will increase the maximum dwell time linearly, but also reduces the responsiveness of
00421 // run-time command executions, like status reports, since these are performed between each dwell
00422 // time step. Also, keep in mind that the Arduino delay timer is not very accurate for long delays.
00423 #define DWELL_TIME_STEP 50 // Integer (1-255) (milliseconds)
00424 
00425 // Creates a delay between the direction pin setting and corresponding step pulse by creating
00426 // another interrupt (Timer2 compare) to manage it. The main Grbl interrupt (Timer1 compare)
00427 // sets the direction pins, and does not immediately set the stepper pins, as it would in
00428 // normal operation. The Timer2 compare fires next to set the stepper pins after the step
00429 // pulse delay time, and Timer2 overflow will complete the step pulse, except now delayed
00430 // by the step pulse time plus the step pulse delay. (Thanks langwadt for the idea!)
00431 // NOTE: Uncomment to enable. The recommended delay must be > 3us, and, when added with the
00432 // user-supplied step pulse time, the total time must not exceed 127us. Reported successful
00433 // values for certain setups have ranged from 5 to 20us.
00434 // #define STEP_PULSE_DELAY 10 // Step pulse delay in microseconds. Default disabled.
00435 
00436 // The number of linear motions in the planner buffer to be planned at any give time. The vast
00437 // majority of RAM that Grbl uses is based on this buffer size. Only increase if there is extra
00438 // available RAM, like when re-compiling for a Mega2560. Or decrease if the Arduino begins to
00439 // crash due to the lack of available RAM or if the CPU is having trouble keeping up with planning
00440 // new incoming motions as they are executed.
00441 // #define BLOCK_BUFFER_SIZE 16 // Uncomment to override default in planner.h.
00442 
00443 // Governs the size of the intermediary step segment buffer between the step execution algorithm
00444 // and the planner blocks. Each segment is set of steps executed at a constant velocity over a
00445 // fixed time defined by ACCELERATION_TICKS_PER_SECOND. They are computed such that the planner
00446 // block velocity profile is traced exactly. The size of this buffer governs how much step
00447 // execution lead time there is for other Grbl processes have to compute and do their thing
00448 // before having to come back and refill this buffer, currently at ~50msec of step moves.
00449 // #define SEGMENT_BUFFER_SIZE 6 // Uncomment to override default in stepper.h.
00450 
00451 // Line buffer size from the serial input stream to be executed. Also, governs the size of
00452 // each of the startup blocks, as they are each stored as a string of this size. Make sure
00453 // to account for the available EEPROM at the defined memory address in settings.h and for
00454 // the number of desired startup blocks.
00455 // NOTE: 80 characters is not a problem except for extreme cases, but the line buffer size
00456 // can be too small and g-code blocks can get truncated. Officially, the g-code standards
00457 // support up to 256 characters. In future versions, this default will be increased, when
00458 // we know how much extra memory space we can re-invest into this.
00459 // #define LINE_BUFFER_SIZE 80  // Uncomment to override default in protocol.h
00460 
00461 // Serial send and receive buffer size. The receive buffer is often used as another streaming
00462 // buffer to store incoming blocks to be processed by Grbl when its ready. Most streaming
00463 // interfaces will character count and track each block send to each block response. So,
00464 // increase the receive buffer if a deeper receive buffer is needed for streaming and avaiable
00465 // memory allows. The send buffer primarily handles messages in Grbl. Only increase if large
00466 // messages are sent and Grbl begins to stall, waiting to send the rest of the message.
00467 // NOTE: Grbl generates an average status report in about 0.5msec, but the serial TX stream at
00468 // 115200 baud will take 5 msec to transmit a typical 55 character report. Worst case reports are
00469 // around 90-100 characters. As long as the serial TX buffer doesn't get continually maxed, Grbl
00470 // will continue operating efficiently. Size the TX buffer around the size of a worst-case report.
00471 #if !defined (STM32F103C8)
00472 // #define RX_BUFFER_SIZE 128 // (1-254) Uncomment to override defaults in serial.h
00473 // #define TX_BUFFER_SIZE 100 // (1-254)
00474 #endif
00475 
00476 // A simple software debouncing feature for hard limit switches. When enabled, the interrupt 
00477 // monitoring the hard limit switch pins will enable the Arduino's watchdog timer to re-check 
00478 // the limit pin state after a delay of about 32msec. This can help with CNC machines with 
00479 // problematic false triggering of their hard limit switches, but it WILL NOT fix issues with 
00480 // electrical interference on the signal cables from external sources. It's recommended to first
00481 // use shielded signal cables with their shielding connected to ground (old USB/computer cables 
00482 // work well and are cheap to find) and wire in a low-pass circuit into each limit pin.
00483 // #define ENABLE_SOFTWARE_DEBOUNCE // Default disabled. Uncomment to enable.
00484 
00485 // Configures the position after a probing cycle during Grbl's check mode. Disabled sets
00486 // the position to the probe target, when enabled sets the position to the start position.
00487 // #define SET_CHECK_MODE_PROBE_TO_START // Default disabled. Uncomment to enable.
00488 
00489 // Force Grbl to check the state of the hard limit switches when the processor detects a pin
00490 // change inside the hard limit ISR routine. By default, Grbl will trigger the hard limits
00491 // alarm upon any pin change, since bouncing switches can cause a state check like this to
00492 // misread the pin. When hard limits are triggered, they should be 100% reliable, which is the
00493 // reason that this option is disabled by default. Only if your system/electronics can guarantee
00494 // that the switches don't bounce, we recommend enabling this option. This will help prevent
00495 // triggering a hard limit when the machine disengages from the switch.
00496 // NOTE: This option has no effect if SOFTWARE_DEBOUNCE is enabled.
00497 // #define HARD_LIMIT_FORCE_STATE_CHECK // Default disabled. Uncomment to enable.
00498 
00499 // Adjusts homing cycle search and locate scalars. These are the multipliers used by Grbl's
00500 // homing cycle to ensure the limit switches are engaged and cleared through each phase of
00501 // the cycle. The search phase uses the axes max-travel setting times the SEARCH_SCALAR to
00502 // determine distance to look for the limit switch. Once found, the locate phase begins and
00503 // uses the homing pull-off distance setting times the LOCATE_SCALAR to pull-off and re-engage
00504 // the limit switch.
00505 // NOTE: Both of these values must be greater than 1.0 to ensure proper function.
00506 // #define HOMING_AXIS_SEARCH_SCALAR  1.5f // Uncomment to override defaults in limits.c.
00507 // #define HOMING_AXIS_LOCATE_SCALAR  10.0f // Uncomment to override defaults in limits.c.
00508 
00509 // Enable the '$RST=*', '$RST=$', and '$RST=#' eeprom restore commands. There are cases where
00510 // these commands may be undesirable. Simply comment the desired macro to disable it.
00511 // NOTE: See SETTINGS_RESTORE_ALL macro for customizing the `$RST=*` command.
00512 #define ENABLE_RESTORE_EEPROM_WIPE_ALL         // '$RST=*' Default enabled. Comment to disable.
00513 #define ENABLE_RESTORE_EEPROM_DEFAULT_SETTINGS // '$RST=$' Default enabled. Comment to disable.
00514 #define ENABLE_RESTORE_EEPROM_CLEAR_PARAMETERS // '$RST=#' Default enabled. Comment to disable.
00515 
00516 // Defines the EEPROM data restored upon a settings version change and `$RST=*` command. Whenever the
00517 // the settings or other EEPROM data structure changes between Grbl versions, Grbl will automatically
00518 // wipe and restore the EEPROM. This macro controls what data is wiped and restored. This is useful
00519 // particularily for OEMs that need to retain certain data. For example, the BUILD_INFO string can be
00520 // written into the Arduino EEPROM via a seperate .INO sketch to contain product data. Altering this
00521 // macro to not restore the build info EEPROM will ensure this data is retained after firmware upgrades.
00522 // NOTE: Uncomment to override defaults in settings.h
00523 // #define SETTINGS_RESTORE_ALL (SETTINGS_RESTORE_DEFAULTS | SETTINGS_RESTORE_PARAMETERS | SETTINGS_RESTORE_STARTUP_LINES | SETTINGS_RESTORE_BUILD_INFO)
00524 
00525 // Enable the '$I=(string)' build info write command. If disabled, any existing build info data must
00526 // be placed into EEPROM via external means with a valid checksum value. This macro option is useful
00527 // to prevent this data from being over-written by a user, when used to store OEM product data.
00528 // NOTE: If disabled and to ensure Grbl can never alter the build info line, you'll also need to enable
00529 // the SETTING_RESTORE_ALL macro above and remove SETTINGS_RESTORE_BUILD_INFO from the mask.
00530 // NOTE: See the included grblWrite_BuildInfo.ino example file to write this string seperately.
00531 #define ENABLE_BUILD_INFO_WRITE_COMMAND // '$I=' Default enabled. Comment to disable.
00532 
00533 // AVR processors require all interrupts to be disabled during an EEPROM write. This includes both
00534 // the stepper ISRs and serial comm ISRs. In the event of a long EEPROM write, this ISR pause can
00535 // cause active stepping to lose position and serial receive data to be lost. This configuration
00536 // option forces the planner buffer to completely empty whenever the EEPROM is written to prevent
00537 // any chance of lost steps.
00538 // However, this doesn't prevent issues with lost serial RX data during an EEPROM write, especially
00539 // if a GUI is premptively filling up the serial RX buffer simultaneously. It's highly advised for
00540 // GUIs to flag these gcodes (G10,G28.1,G30.1) to always wait for an 'ok' after a block containing
00541 // one of these commands before sending more data to eliminate this issue.
00542 // NOTE: Most EEPROM write commands are implicitly blocked during a job (all '$' commands). However,
00543 // coordinate set g-code commands (G10,G28/30.1) are not, since they are part of an active streaming
00544 // job. At this time, this option only forces a planner buffer sync with these g-code commands.
00545 #define FORCE_BUFFER_SYNC_DURING_EEPROM_WRITE // Default enabled. Comment to disable.
00546 
00547 // In Grbl v0.9 and prior, there is an old outstanding bug where the `WPos:` work position reported
00548 // may not correlate to what is executing, because `WPos:` is based on the g-code parser state, which
00549 // can be several motions behind. This option forces the planner buffer to empty, sync, and stop
00550 // motion whenever there is a command that alters the work coordinate offsets `G10,G43.1,G92,G54-59`.
00551 // This is the simplest way to ensure `WPos:` is always correct. Fortunately, it's exceedingly rare
00552 // that any of these commands are used need continuous motions through them.
00553 #define FORCE_BUFFER_SYNC_DURING_WCO_CHANGE // Default enabled. Comment to disable.
00554 
00555 // By default, Grbl disables feed rate overrides for all G38.x probe cycle commands. Although this
00556 // may be different than some pro-class machine control, it's arguable that it should be this way. 
00557 // Most probe sensors produce different levels of error that is dependent on rate of speed. By 
00558 // keeping probing cycles to their programmed feed rates, the probe sensor should be a lot more
00559 // repeatable. If needed, you can disable this behavior by uncommenting the define below.
00560 // #define ALLOW_FEED_OVERRIDE_DURING_PROBE_CYCLES // Default disabled. Uncomment to enable.
00561 
00562 // Enables and configures parking motion methods upon a safety door state. Primarily for OEMs
00563 // that desire this feature for their integrated machines. At the moment, Grbl assumes that
00564 // the parking motion only involves one axis, although the parking implementation was written
00565 // to be easily refactored for any number of motions on different axes by altering the parking
00566 // source code. At this time, Grbl only supports parking one axis (typically the Z-axis) that
00567 // moves in the positive direction upon retracting and negative direction upon restoring position.
00568 // The motion executes with a slow pull-out retraction motion, power-down, and a fast park.
00569 // Restoring to the resume position follows these set motions in reverse: fast restore to
00570 // pull-out position, power-up with a time-out, and plunge back to the original position at the
00571 // slower pull-out rate.
00572 // NOTE: Still a work-in-progress. Machine coordinates must be in all negative space and
00573 // does not work with HOMING_FORCE_SET_ORIGIN enabled. Parking motion also moves only in
00574 // positive direction.
00575 // #define PARKING_ENABLE  // Default disabled. Uncomment to enable
00576 
00577 // Configure options for the parking motion, if enabled.
00578 #define PARKING_AXIS Z_AXIS // Define which axis that performs the parking motion
00579 #define PARKING_TARGET -5.0f // Parking axis target. In mm, as machine coordinate [-max_travel,0].
00580 #define PARKING_RATE 500.0f // Parking fast rate after pull-out in mm/min.
00581 #define PARKING_PULLOUT_RATE 100.0f // Pull-out/plunge slow feed rate in mm/min.
00582 #define PARKING_PULLOUT_INCREMENT 5.0f // Spindle pull-out and plunge distance in mm. Incremental distance.
00583                                       // Must be positive value or equal to zero.
00584 
00585 // Enables a special set of M-code commands that enables and disables the parking motion. 
00586 // These are controlled by `M56`, `M56 P1`, or `M56 Px` to enable and `M56 P0` to disable. 
00587 // The command is modal and will be set after a planner sync. Since it is g-code, it is 
00588 // executed in sync with g-code commands. It is not a real-time command.
00589 // NOTE: PARKING_ENABLE is required. By default, M56 is active upon initialization. Use 
00590 // DEACTIVATE_PARKING_UPON_INIT to set M56 P0 as the power-up default.
00591 // #define ENABLE_PARKING_OVERRIDE_CONTROL   // Default disabled. Uncomment to enable
00592 // #define DEACTIVATE_PARKING_UPON_INIT // Default disabled. Uncomment to enable.
00593 
00594 // This option will automatically disable the laser during a feed hold by invoking a spindle stop
00595 // override immediately after coming to a stop. However, this also means that the laser still may
00596 // be reenabled by disabling the spindle stop override, if needed. This is purely a safety feature
00597 // to ensure the laser doesn't inadvertently remain powered while at a stop and cause a fire.
00598 #define DISABLE_LASER_DURING_HOLD // Default enabled. Comment to disable.
00599 
00600 /* ---------------------------------------------------------------------------------------
00601    OEM Single File Configuration Option
00602 
00603    Instructions: Paste the cpu_map and default setting definitions below without an enclosing
00604    #ifdef. Comment out the CPU_MAP_xxx and DEFAULT_xxx defines at the top of this file, and
00605    the compiler will ignore the contents of defaults.h and cpu_map.h and use the definitions
00606    below.
00607 */
00608 
00609 // Paste CPU_MAP definitions here.
00610 
00611 // Paste default settings definitions here.
00612 
00613 
00614 #endif