Reduced default step pulse length to 5 microseconds.

Added HAL parameter for minimum step pulse length set by driver, used for validation of $0 setting.
Changed HAL API signature for outputting step pulses, optimized to allow drivers to only change direction outputs when there is an actual direction change.
Improved handling of overrides at end of program when all motion is buffered. Possible fix for issue #714.
Some optimizations to allow higher step rates.

Author: terjeio

README.md

@@ -1,6 +1,6 @@
 ## grblHAL ##
 
-Latest build date is 20250320, see the [changelog](changelog.md) for details.  
+Latest build date is 20250328, see the [changelog](changelog.md) for details.  
 
 > [!NOTE]
 >  A settings reset will be performed on an update of builds prior to 20241208. Backup and restore of settings is recommended.  
@@ -89,4 +89,4 @@ G/M-codes not supported by [legacy Grbl](https://github.com/gnea/grbl/wiki) are
 Some [plugins](https://github.com/grblHAL/plugins) implements additional M-codes.
 
 ---
-20250320
+20250328

changelog.md

@@ -1,5 +1,34 @@
 ## grblHAL changelog
 
+<a name="20250328">Build 20250328
+
+Core:
+
+* Reduced default step pulse length to 5 microseconds. Added HAL parameter for minimum step pulse length set by driver, used for validation of $0 setting.
+
+* Changed HAL API signature for outputting step pulses, optimized to allow drivers to only change direction outputs when there is an actual direction change.
+
+* Improved handling of overrides at end of program when all motion is buffered. Possible fix for issue [#714](https://github.com/grblHAL/core/discussions/714).
+
+* Some optimizations to allow higher step rates.
+
+Drivers:
+
+* All: updated for core HAL signature change.
+
+* Most: added hardcoded (compile time overridable) minimum step pulse off time, defaults to 2 microseconds. This will limit max. possible step rate with a given step pulse length \(from $0 setting\).
+
+* iMRXT1062, RP2040: reduced minimum step pulse length to 1 microsecond.
+
+* STM32F1xx, STM32F3xx: increased minimum step pulse length to 3.5 microseconds.
+
+* STM32F7xx: reduced minimum step pulse length to 1.5 microsecond, moved critical code run in IRQ context to ITC RAM.
+
+* STM32F1xx, STM32F3xx, STM32F4xx and STM32F7xx: changed to use single timer for step generation, eliminates \(reduces?\) risk for lost steps at very high step rates and reduces jitter.  
+Added new compile time tuning parameters for interrupt latency used for step pulse timings, board developers may want to check and possibly override these in their board maps.
+
+---
+
 <a name="20250320">Build 20250320
 
 Core:

config.h

@@ -530,7 +530,7 @@ Set to \ref On or 1 to enable experimental support for expressions.
 Some LinuxCNC extensions are supported, conditionals and subroutines are not.
 */
 #if !defined NGC_EXPRESSIONS_ENABLE || defined __DOXYGEN__
-#define NGC_EXPRESSIONS_ENABLE Off
+#define NGC_EXPRESSIONS_ENABLE On
 #endif
 
 /*! \def NGC_PARAMETERS_ENABLE
@@ -1818,15 +1818,15 @@ machine limits this setting, when enabled, keeps them with the limits.
 <br>__NOTE:__ The different MCUs supported have different interrupt latencies
 and some drivers may enable features that are not available on others. This may
 lead to this setting not beeing respected exactly over the supported range.
-Typically drivers are calibrated to be correct for 10 microsecond pulse lengths,
+Typically drivers are calibrated to be correct for 5 microsecond pulse lengths,
 however if a precise pulse length is required it should be measured and
 adjusted either by changing this value or by changing the `STEP_PULSE_LATENCY` symbol
 value that many drivers supports. Note that `STEP_PULSE_LATENCY` symbol is driver
 specific - it is _not_ defined in the core.
 */
 ///@{
 #if !defined DEFAULT_STEP_PULSE_MICROSECONDS || defined __DOXYGEN__
-#define DEFAULT_STEP_PULSE_MICROSECONDS 10.0f
+#define DEFAULT_STEP_PULSE_MICROSECONDS 5.0f
 #endif
 ///@}
 

crossbar.c

@@ -117,7 +117,7 @@ void xbar_set_homing_source (void)
 }
 
 // Returns limit signals used by homing when home signals are not available.
-limit_signals_t xbar_get_homing_source (void)
+ISR_CODE limit_signals_t xbar_get_homing_source (void)
 {
     return home_source;
 }

driver_opts2.h

@@ -49,9 +49,9 @@
 #error "MPG_MODE_PIN must be defined!"
 #endif
 
-#if KEYPAD_ENABLE == 1 && !defined(I2C_STROBE_PORT)
+#if KEYPAD_ENABLE == 1 && !defined(I2C_STROBE_PIN)
 #error Keypad plugin not supported!
-#elif I2C_STROBE_ENABLE && !defined(I2C_STROBE_PORT)
+#elif I2C_STROBE_ENABLE && !defined(I2C_STROBE_PIN)
 #error "I2C strobe not supported!"
 #endif
 

gcode.c

@@ -3821,8 +3821,7 @@ status_code_t gc_execute_block (char *block)
 
                     mc_line(gc_block.values.xyz, &plan_data);
 
-                    protocol_buffer_synchronize();    // Wait until synchronized move is finished,
-                    sys.override.control = overrides; // then restore previous override disable status.
+                    mc_override_ctrl_update(overrides);  // Wait until synchronized move is finished, then restore previous override disable status.
                 }
                 break;
 
@@ -3838,7 +3837,7 @@ status_code_t gc_execute_block (char *block)
 
                     mc_thread(&plan_data, gc_state.position, &thread, overrides.feed_hold_disable);
 
-                    sys.override.control = overrides; // then restore previous override disable status.
+                    mc_override_ctrl_update(overrides); // Wait until synchronized move is finished, then restore previous override disable status.
                 }
                 break;
 
@@ -3889,9 +3888,7 @@ status_code_t gc_execute_block (char *block)
     // [21. Program flow ]:
     // M0,M1,M2,M30,M60: Perform non-running program flow actions. During a program pause, the buffer may
     // refill and can only be resumed by the cycle start run-time command.
-    gc_state.modal.program_flow = gc_block.modal.program_flow;
-
-    if(gc_state.modal.program_flow || sys.flags.single_block) {
+    if((gc_state.modal.program_flow = gc_block.modal.program_flow) || sys.flags.single_block) {
 
         protocol_buffer_synchronize(); // Sync and finish all remaining buffered motions before moving on.
 

grbl.h

@@ -42,7 +42,7 @@
 #else
 #define GRBL_VERSION "1.1f"
 #endif
-#define GRBL_BUILD 20250317
+#define GRBL_BUILD 20250328
 
 #define GRBL_URL "https://github.com/grblHAL"
 
@@ -52,7 +52,7 @@
 #ifdef GRBL_ESP32
 #include "esp_attr.h"
 #define ISR_CODE IRAM_ATTR
-#else
+#elif !defined(ISR_CODE)
 // #define ISR_CODE __attribute__((long_call, section(".data")))
 // Used to decorate code run in interrupt context.
 // Do not remove or change unless you know what you are doing.

grbllib.c

@@ -212,6 +212,7 @@ int grbl_enter (void)
     hal.irq_disable = dummy_handler;
     hal.irq_claim = dummy_irq_claim;
     hal.nvs.size = GRBL_NVS_SIZE;
+    hal.step_us_min = 2.0f;
     hal.coolant_cap.flood = On;
     hal.limits.interrupt_callback = limit_interrupt_handler;
     hal.control.interrupt_callback = control_interrupt_handler;
@@ -536,7 +537,7 @@ ISR_CODE bool ISR_FUNC(task_add_delayed)(foreground_task_ptr fn, void *data, uin
     return task != NULL;
 }
 
-void task_delete (foreground_task_ptr fn, void *data)
+ISR_CODE void task_delete (foreground_task_ptr fn, void *data)
 {
     core_task_t *task, *prev = NULL;
 

hal.h

@@ -562,6 +562,7 @@ typedef struct {
     char *driver_url;               //!< Pointer to optional URL for the driver.
     char *board;                    //!< Pointer to optional board name string.
     char *board_url;                //!< Pointer to optional URL for the board.
+    float step_us_min;              //!< Minimum step pulse width (microseconds).
     uint32_t f_step_timer;          //!< Frequency of main stepper timer in Hz.
     uint32_t f_mcu;                 //!< Frequency of MCU in MHz.
     uint32_t rx_buffer_size;        //!< Input stream buffer size in bytes.

nuts_bolts.h

@@ -138,6 +138,30 @@ typedef union {
     };
 } axes_signals_t;
 
+typedef union {
+    int32_t value[N_AXIS];
+    struct {
+        int32_t x;
+        int32_t y;
+        int32_t z;
+#ifdef A_AXIS
+        int32_t a;
+#endif
+#ifdef B_AXIS
+        int32_t b;
+#endif
+#ifdef C_AXIS
+        int32_t c;
+#endif
+#ifdef U_AXIS
+        int32_t u;
+#endif
+#ifdef V_AXIS
+        int32_t v;
+#endif
+    };
+} mpos_t;
+
 typedef union {
     float values[2];
     struct {

planner.c

@@ -394,6 +394,8 @@ static inline float limit_max_rate_by_axis_maximum (float *unit_vec)
    to execute the special system motion. */
 bool plan_buffer_line (float *target, plan_line_data_t *pl_data)
 {
+    static axes_signals_t direction = {};
+
     // Prepare and initialize new block. Copy relevant pl_data for block execution.
     plan_block_t *block = block_buffer_head;
     int32_t target_steps[N_AXIS], position_steps[N_AXIS], delta_steps;
@@ -427,23 +429,25 @@ bool plan_buffer_line (float *target, plan_line_data_t *pl_data)
 
         target_steps[idx] = lroundf(target[idx] * settings.axis[idx].steps_per_mm);
         if((delta_steps = target_steps[idx] - position_steps[idx])) {
-            block->steps[idx] = labs(delta_steps);
-            block->step_event_count = max(block->step_event_count, block->steps[idx]);
+            block->steps.value[idx] = labs(delta_steps);
+            block->step_event_count = max(block->step_event_count, block->steps.value[idx]);
             unit_vec[idx] = (float)delta_steps / settings.axis[idx].steps_per_mm; // Store unit vector numerator
+            // Set direction bits. Bit enabled always means direction is negative.
+            if(delta_steps < 0)
+                direction.bits |= bit(idx);
+            else
+                direction.bits &= ~bit(idx);
 #if N_AXIS > 3  && ROTARY_FIX
             motion.mask |= bit(idx);
 #endif
         } else {
-            block->steps[idx] = 0;
+            block->steps.value[idx] = 0;
             unit_vec[idx] = 0.0f; // Store unit vector numerator
         }
-
-        // Set direction bits. Bit enabled always means direction is negative.
-        if (delta_steps < 0)
-            block->direction_bits.mask |= bit(idx);
-
     } while(idx);
 
+    block->direction = direction;
+
     // Calculate RPMs to be used for Constant Surface Speed (CSS) calculations.
     if(block->spindle.css) {
 

planner.h

@@ -3,7 +3,7 @@
 
   Part of grblHAL
 
-  Copyright (c) 2019-2024 Terje Io
+  Copyright (c) 2019-2025 Terje Io
   Copyright (c) 2011-2016 Sungeun K. Jeon for Gnea Research LLC
   Copyright (c) 2009-2011 Simen Svale Skogsrud
 
@@ -43,14 +43,38 @@ typedef union {
     };
 } planner_cond_t;
 
+typedef union {
+    uint32_t value[N_AXIS];
+    struct {
+        uint32_t x;
+        uint32_t y;
+        uint32_t z;
+#ifdef A_AXIS
+        uint32_t a;
+#endif
+#ifdef B_AXIS
+        uint32_t b;
+#endif
+#ifdef C_AXIS
+        uint32_t c;
+#endif
+#ifdef U_AXIS
+        uint32_t u;
+#endif
+#ifdef V_AXIS
+        uint32_t v;
+#endif
+    };
+} steps_t;
+
 // This struct stores a linear movement of a g-code block motion with its critical "nominal" values
 // are as specified in the source g-code.
 typedef struct plan_block {
     // Fields used by the bresenham algorithm for tracing the line
     // NOTE: Used by stepper algorithm to execute the block correctly. Do not alter these values.
-    uint32_t steps[N_AXIS];         // Step count along each axis
+    steps_t steps;                  // Step count along each axis
     uint32_t step_event_count;      // The maximum step axis count and number of steps required to complete this block.
-    axes_signals_t direction_bits;  // The direction bit set for this block (refers to *_DIRECTION_PIN in config.h)
+    axes_signals_t direction;       // The direction bit set for this block (refers to *_DIRECTION_PIN in config.h)
 
     offset_id_t offset_id;
     // Block condition data to ensure correct execution depending on states and overrides.

protocol.c

@@ -138,7 +138,7 @@ static bool recheck_line (char *line, line_flags_t *flags)
 }
 
 /*
-  GRBL PRIMARY LOOP:
+  grblHAL PRIMARY LOOP:
 */
 bool protocol_main_loop (void)
 {
@@ -274,8 +274,15 @@ bool protocol_main_loop (void)
                     }
                 } else if(*line == '[' && grbl.on_user_command)
                     gc_state.last_error = grbl.on_user_command(line);
-                else if (state_get() & (STATE_ALARM|STATE_ESTOP|STATE_JOG)) // Everything else is gcode. Block if in alarm, eStop or jog mode.
-                    gc_state.last_error = Status_SystemGClock;
+                else if(state_get() & (STATE_ALARM|STATE_ESTOP|STATE_JOG)) { // Everything else is gcode. Block if in alarm, eStop or jog mode.
+                    if(*line == CMD_PROGRAM_DEMARCATION && line[1] == '\0' && (state_get() & (STATE_ALARM|STATE_ESTOP))) {
+                        gc_state.file_run = !gc_state.file_run;
+                        gc_state.last_error = Status_OK;
+                        if(grbl.on_file_demarcate)
+                            grbl.on_file_demarcate(gc_state.file_run);
+                    } else
+                        gc_state.last_error = Status_SystemGClock;
+                }
 #if COMPATIBILITY_LEVEL == 0
                 else if(gc_state.last_error == Status_OK || gc_state.last_error == Status_GcodeToolChangePending) { // Parse and execute g-code block.
 #else
@@ -383,7 +390,7 @@ bool protocol_buffer_synchronize (void)
     // If system is queued, ensure cycle resumes if the auto start flag is present.
     protocol_auto_cycle_start();
 
-    sys.flags.synchronizing = On;
+    sys.flags.synchronizing = gc_state.modal.program_flow == ProgramFlow_Running;
     while ((ok = protocol_execute_realtime()) && (plan_get_current_block() || state_get() == STATE_CYCLE));
     sys.flags.synchronizing = Off;
 

report.c

@@ -1338,9 +1338,11 @@ void report_realtime_status (void)
 
         if (override_counter > 0 && !report.overrides)
             override_counter--;
-        else if((report.overrides = !report.wco)) {
-            report.spindle = report.spindle || spindle_0_state.on;
-            report.coolant = report.coolant || hal.coolant.get_state().value != 0;
+        else {
+            if((report.overrides = !report.wco)) {
+                report.spindle = report.spindle || spindle_0_state.on;
+                report.coolant = report.coolant || hal.coolant.get_state().value != 0;
+            }
             override_counter = state & (STATE_HOMING|STATE_CYCLE|STATE_HOLD|STATE_JOG|STATE_SAFETY_DOOR)
                                 ? (REPORT_OVERRIDE_REFRESH_BUSY_COUNT - 1) // Reset counter for slow refresh
                                 : (REPORT_OVERRIDE_REFRESH_IDLE_COUNT - 1);