stepper.h

Go to the documentation of this file.

/*
  stepper.h - stepper motor driver: executes motion plans of planner.c using the stepper motors
 
  Part of grblHAL
 
  Copyright (c) 2019-2025 Terje Io
  Copyright (c) 2011-2016 Sungeun K. Jeon for Gnea Research LLC
  Copyright (c) 2009-2011 Simen Svale Skogsrud
 
  grblHAL is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  grblHAL is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with grblHAL. If not, see <http://www.gnu.org/licenses/>.
*/
 
#include "planner.h"
 
#ifndef _STEPPER_H_
#define _STEPPER_H_
 
typedef enum {
    SquaringMode_Both = 0,  
    SquaringMode_A,         
    SquaringMode_B,         
} squaring_mode_t;
 
typedef enum {
    Ramp_Accel,
    Ramp_Cruise,
    Ramp_Decel,
    Ramp_DecelOverride
} ramp_type_t;
 
typedef struct st_block {
    uint_fast8_t id;                  
    struct st_block *next;            
    uint32_t steps[N_AXIS];
    uint32_t step_event_count;
    float steps_per_mm;
    float millimeters;
    float programmed_rate;
    char *message;                     
    output_command_t *output_commands; 
    axes_signals_t direction_bits;
    gc_override_flags_t overrides;     
    bool backlash_motion;
    bool dynamic_rpm;                  
    offset_id_t offset_id;
    spindle_ptrs_t *spindle;           
} st_block_t;
 
typedef struct st_segment {
    uint_fast8_t id;                    
    struct st_segment *next;            
    st_block_t *exec_block;             
    uint32_t cycles_per_tick;           
    float current_rate;
    float target_position;              
    uint_fast16_t n_step;               
    uint_fast16_t spindle_pwm;          
    float spindle_rpm;                  
    ramp_type_t ramp_type;              
    bool spindle_sync;                  
    bool cruising;                      
    uint_fast8_t amass_level;           
    spindle_update_pwm_ptr update_pwm;  
    spindle_update_rpm_ptr update_rpm;  
} segment_t;
 
typedef struct stepper {
    uint32_t counter_x,             
             counter_y,             
             counter_z              
    #ifdef A_AXIS
           , counter_a              
    #endif
    #ifdef B_AXIS
           , counter_b              
    #endif
    #ifdef C_AXIS
           , counter_c              
    #endif
    #ifdef U_AXIS
           , counter_u              
    #endif
    #ifdef V_AXIS
           , counter_v              
    #endif
;
    bool new_block;                 
    bool dir_change;                
    axes_signals_t step_outbits;    
    axes_signals_t dir_outbits;     
    uint32_t steps[N_AXIS];         
    uint_fast8_t amass_level;       
//    uint_fast16_t spindle_pwm;
    uint_fast16_t step_count;       
    uint32_t step_event_count;      
    st_block_t *exec_block;         
    segment_t *exec_segment;        
} stepper_t;
 
// Initialize and setup the stepper motor subsystem
void stepper_init (void);
 
// Enable steppers, but cycle does not start unless called by motion control or realtime command.
void st_wake_up (void);
 
// Immediately disables steppers
void st_go_idle (void);
 
// Returns true if motion is ongoing
bool st_is_stepping (void);
 
// Reset the stepper subsystem variables
void st_reset (void);
 
// Called by spindle_set_state() to inform about RPM changes.
void st_rpm_changed (float rpm);
 
// Changes the run state of the step segment buffer to execute the special parking motion.
void st_parking_setup_buffer (void);
 
// Restores the step segment buffer to the normal run state after a parking motion.
void st_parking_restore_buffer (void);
 
// Reloads step segment buffer. Called continuously by realtime execution system.
void st_prep_buffer (void);
 
// Called by planner_recalculate() when the executing block is updated by the new plan.
void st_update_plan_block_parameters (bool fast_hold);
 
// Called by realtime status reporting if realtime rate reporting is enabled in config.h.
float st_get_realtime_rate (void);
 
void stepper_driver_interrupt_handler (void);
 
offset_id_t st_get_offset_id (void);
 
#endif