gcode.h

Go to the documentation of this file.

/*
  gcode.h - rs274/ngc parser.
 
  Part of grblHAL
 
  Copyright (c) 2017-2026 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/>.
*/
 
#ifndef _GCODE_H_
#define _GCODE_H_
 
#include "nuts_bolts.h"
#include "coolant_control.h"
#include "spindle_control.h"
#include "errors.h"
#include "vfs.h"
 
#define MAX_OFFSET_ENTRIES 4 // must be a power of 2
 
typedef int32_t tool_id_t;
typedef int16_t pocket_id_t;
typedef uint16_t macro_id_t;
typedef int8_t offset_id_t;
 
// Define command actions for within execution-type modal groups (motion, stopping, non-modal). Used
// internally by the parser to know which command to execute.
// NOTE: Some values are assigned specific values to make g-code state reporting and parsing
// compile a little smaller. Although not
// ideal, just be careful with values that state 'do not alter' and check both report.c and gcode.c
// to see how they are used, if you need to alter them.
 
typedef enum {
    NonModal_NoAction = 0,                  
    NonModal_Dwell = 4,                     
    NonModal_Settings = 10,                 
    NonModal_GoHome_0 = 28,                 
    NonModal_SetHome_0 = 38,                
    NonModal_GoHome_1 = 30,                 
    NonModal_SetHome_1 = 40,                
    NonModal_AbsoluteOverride = 53,         
    NonModal_SetCoordinateOffset = 92,      
    NonModal_ResetCoordinateOffset = 102,   
    NonModal_ClearCoordinateOffset = 112,   
 #if ENABLE_ACCELERATION_PROFILES
    NonModal_RestoreCoordinateOffset = 122, 
    NonModal_SetAccelerationProfile = 187   
 #else
    NonModal_RestoreCoordinateOffset = 122  
 #endif
} non_modal_t;
 
typedef enum {
    ToolAction_None = 0,                    
    ToolAction_Change = 6,                  
    ToolAction_Set = 61,                    
} tool_action_t;
 
typedef enum {
    MacroCall_End = 0,                      
    MacroCall_NonModal = 65,                
    MacroCall_Modal = 66,                   
    MacroCall_Modal1 = 166,                 
    MacroCall_NonModal98 = 98,              
} macro_call_t;
 
typedef enum {
    ModalState_NoAction = 0,                
    ModalState_Save = 70,                   
    ModalState_Invalidate = 71,             
    ModalState_Restore = 72,                
    ModalState_SaveAutoRestore = 73,        
} modal_state_action_t;
 
typedef enum {
    MotionMode_Seek = 0,                    
    MotionMode_Linear = 1,                  
    MotionMode_CwArc = 2,                   
    MotionMode_CcwArc = 3,                  
    MotionMode_CubicSpline = 5,             
    MotionMode_QuadraticSpline = 51,        
    MotionMode_SpindleSynchronized = 33,    
    MotionMode_RigidTapping = 331,          
    MotionMode_DrillChipBreak = 73,         
    MotionMode_Threading = 76,              
    MotionMode_CannedCycle81 = 81,          
    MotionMode_CannedCycle82 = 82,          
    MotionMode_CannedCycle83 = 83,          
    MotionMode_CannedCycle84 = 84,          
    MotionMode_CannedCycle85 = 85,          
    MotionMode_CannedCycle86 = 86,          
    MotionMode_CannedCycle89 = 89,          
    MotionMode_ProbeToward = 140,           
    MotionMode_ProbeTowardNoError = 141,    
    MotionMode_ProbeAway = 142,             
    MotionMode_ProbeAwayNoError = 143,      
    MotionMode_None = 80                    
} motion_mode_t;
 
typedef enum {
    PlaneSelect_XY = 0, 
    PlaneSelect_ZX = 1, 
    PlaneSelect_YZ = 2  
} plane_select_t;
 
// Modal Group G4: Arc IJK distance mode
//#define DISTANCE_ARC_MODE_INCREMENTAL 0 // G91.1 - Default, must be zero
 
 
typedef enum {
    FeedMode_UnitsPerMin = 0,   
    FeedMode_InverseTime = 1,   
    FeedMode_UnitsPerRev = 2    
} feed_mode_t;
 
// Modal Group G7: Cutter radius compensation mode
typedef enum {
    CComp_Off = 0, 
    CComp_Left,    
    CComp_Right    
} ccomp_mode_t;
 
typedef enum {
    ToolLengthOffset_Cancel = 0,         
    ToolLengthOffset_Enable = 1,         
    ToolLengthOffset_EnableDynamic = 2,  
    ToolLengthOffset_ApplyAdditional = 3 
} tool_offset_mode_t;
 
typedef enum {
    CCRetractMode_Previous = 0,  
    CCRetractMode_RPos = 1       
} cc_retract_mode_t;
 
 
typedef enum  {
    CoordinateSystem_G54 = 0,                       
    CoordinateSystem_G55,                           
    CoordinateSystem_G56,                           
    CoordinateSystem_G57,                           
    CoordinateSystem_G58,                           
    CoordinateSystem_G59,                           
#if COMPATIBILITY_LEVEL <= 1
    CoordinateSystem_G59_1,                         
    CoordinateSystem_G59_2,                         
    CoordinateSystem_G59_3,                         
#endif
    N_WorkCoordinateSystems,                        
    CoordinateSystem_G28 = N_WorkCoordinateSystems, 
    CoordinateSystem_G30,                           
    CoordinateSystem_G92,                           
    N_CoordinateSystems                             
}  __attribute__ ((__packed__)) coord_system_id_t;
 
 
typedef enum {
    ControlMode_ExactPath = 0,      
    ControlMode_ExactStop = 1,      
    ControlMode_PathBlending = 2    
} control_mode_t;
 
typedef enum {
    ProgramFlow_Running = 0,        
    ProgramFlow_Paused  = 3,        
    ProgramFlow_OptionalStop = 1,   
    ProgramFlow_CompletedM2 = 2,    
    ProgramFlow_CompletedM30 = 30,  
    ProgramFlow_CompletedM60 = 60,  
    ProgramFlow_Return = 99,        
    ProgramFlow_EndPercent = 255    
} program_flow_t;
 
// Modal Group M9: Override control
typedef enum {
    Override_FeedSpeedEnable = 48,  
    Override_FeedSpeedDisable = 49, 
    Override_FeedRate = 50,         
    Override_SpindleSpeed = 51,     
    Override_FeedHold = 53,         
    Override_Parking = 56           
} override_mode_t;
 
typedef enum {
    IoMCode_OutputOnSynced = 62,        
    IoMCode_OutputOffSynced = 63,       
    IoMCode_OutputOnImmediate = 64,     
    IoMCode_OutputOffImmediate = 65,    
    IoMCode_WaitOnInput = 66,           
    IoMCode_AnalogOutSynced = 67,       
    IoMCode_AnalogOutImmediate = 68,    
} io_mcode_t;
 
typedef enum {
    OpenPNP_SetPinState = 42,           
    UserMCode_Generic1 = 101,           
    UserMCode_Generic2 = 102,           
    UserMCode_Generic3 = 103,           
    UserMCode_Generic4 = 104,           
    Fan_On = 106,                       
    Fan_Off = 107,                      
    OpenPNP_GetCurrentPosition = 114,   
    OpenPNP_FirmwareInfo = 115,         
    Trinamic_DebugReport = 122,         
    Trinamic_ReadRegister = 123,        
    Trinamic_WriteRegister = 124,       
    LaserPPI_Enable = 126,              
    LaserPPI_Rate = 127,                
    LaserPPI_PulseLength = 128,         
    Laser_Overdrive = 129,              
    OpenPNP_GetPinState = 143,          
    OpenPNP_GetADCScaled = 144,         
    OpenPNP_SetADCScaling = 145,        
    RGB_WriteLEDs = 150,                
    Plasma_SelectMaterial = 190,        
    OpenPNP_SetJerk = 20130,            
    OpenPNP_SetAcceleration = 204,      
    SetFeedOverrides = 220,             
    PWMServo_SetPosition= 280,          
    RGB_Inspection_Light = 356,         
    OpenPNP_FinishMoves = 400,          
    Probe_Deploy = 401,                 
    Probe_Stow = 402,                   
    OpenPNP_SettingsReset = 502,        
    Trinamic_ModeToggle = 569,          
    Macro_Execute0 = 810,               
    Macro_Execute1 = 811,               
    Macro_Execute2 = 812,               
    Macro_Execute3 = 813,               
    Macro_Execute4 = 814,               
    Macro_Execute5 = 815,               
    Macro_Execute6 = 816,               
    Macro_Execute7 = 817,               
    Macro_Execute8 = 818,               
    Macro_Execute9 = 819,               
    Trinamic_StepperCurrent = 906,      
    Trinamic_ReportPrewarnFlags = 911,  
    Trinamic_ClearPrewarnFlags = 912,   
    Trinamic_HybridThreshold = 913,     
    Trinamic_HomingSensitivity = 914,   
    Trinamic_ChopperTiming = 919,       
    Sienci_Atci_Enable = 960,           
    Spindle_Select = UserMCode_Generic4 
} user_mcode_t;
 
typedef struct output_command {
    bool is_digital;
    uint8_t port;
    int32_t value;
    struct output_command *next;
} output_command_t;
 
typedef enum {
    WaitMode_Immediate = 0, 
    WaitMode_Rise,          
    WaitMode_Fall,          
    WaitMode_High,          
    WaitMode_Low,           
    WaitMode_Max            
} wait_mode_t;
 
typedef enum {
    GCUpdatePos_Target = 0, 
    GCUpdatePos_System,     
    GCUpdatePos_None        
} pos_update_t;
 
typedef enum {
    GCProbe_Found = GCUpdatePos_System,     
    GCProbe_Abort = GCUpdatePos_None,       
    GCProbe_FailInit = GCUpdatePos_None,    
    GCProbe_FailEnd = GCUpdatePos_Target,   
  #if SET_CHECK_MODE_PROBE_TO_START
    GCProbe_CheckMode = GCUpdatePos_None    
  #else
    GCProbe_CheckMode = GCUpdatePos_Target  
  #endif
} gc_probe_t;
 
typedef struct {
    ccomp_mode_t side;
    bool first_move;
    float radius;
} gc_ccomp_t;
 
typedef union {
    uint16_t value;
    struct {
        uint16_t jog_motion          :1,
                 canned_cycle_change :1, // Use motion_mode_changed?
                 arc_is_clockwise    :1,
                 probe_is_away       :1,
                 probe_is_no_error   :1,
                 spindle_force_sync  :1,
                 laser_disable       :1,
                 laser_is_motion     :1,
                 set_coolant         :1,
                 motion_mode_changed :1,
                 reserved            :6;
    };
} gc_parser_flags_t;
 
typedef union {
    uint16_t value;
    struct {
        uint16_t spindle_rpm_disable  :8,
                 feed_rates_disable   :1,
                 feed_hold_disable    :1,
                 parking_disable      :1,
                 spindle_wait_disable :1,
                 reserved             :2,
                 sync                 :1;
    };
    struct {
        uint16_t spindle_rpm          :8,
                 feed_rates           :1,
                 feed_hold            :1,
                 parking              :1,
                 spindle              :1,
                 reserved1            :2,
                 reserved2            :1; // sync synonym
    };
} gc_override_flags_t;
 
typedef struct {
    coord_system_id_t id;
    coord_system_data_t data;
} coord_system_t;
 
typedef struct {
    float d;                        
    float e;                        
    float f;                        
    float h;                        
    float ijk[3];                   
    float k;                        
    float m;                        
    float p;                        
    float q;                        
    float r;                        
    float s;                        
    float t;                        
#ifndef A_AXIS
    float a;                        
#endif
#ifndef B_AXIS
    float b;                        
#endif
#ifndef C_AXIS
    float c;                        
#endif
#ifndef U_AXIS
    float u;                        
#endif
#ifndef V_AXIS
    float v;                        
#endif
#ifndef W_AXIS
    float w;                        
#endif
    float xyz[N_AXIS];              
#if LATHE_UVW_OPTION
    float uvw[3];                   
#endif
    int32_t $;                      
    int32_t n;                      
    uint32_t o;                     
    uint32_t l;                     
} gc_values_t;
 
typedef union {
    uint32_t mask;      
    uint32_t value;     
    struct {
        uint32_t $ :1, 
                 a :1, 
                 b :1, 
                 c :1, 
                 i :1, 
                 j :1, 
                 k :1, 
                 d :1, 
                 e :1, 
                 f :1, 
                 g :1, 
                 h :1, 
                 l :1, 
                 m :1, 
                 n :1, 
                 o :1, 
                 p :1, 
                 q :1, 
                 r :1, 
                 s :1, 
                 t :1, 
                 u :1, 
                 v :1, 
                 w :1, 
                 x :1, 
                 y :1, 
                 z :1; 
    };
} parameter_words_t;
 
typedef union {
    uint8_t value;
    struct {
        uint8_t is_rpm_rate_adjusted :1,
                is_laser_ppi_mode    :1,
                unassigned           :6;
 
    };
} spindle_cond_t;
 
typedef struct {
    spindle_state_t state;          
    spindle_rpm_mode_t rpm_mode;    
    spindle_cond_t condition;       
    spindle_css_data_t *css;        
    float rpm;                      
    spindle_ptrs_t *hal;            
} spindle_t;
 
typedef struct {
    spindle_state_t state;          
    spindle_rpm_mode_t rpm_mode;    
} spindle_modal_t;
 
// NOTE: When this struct is zeroed, the above defines set the defaults for the system.
typedef struct {
    motion_mode_t motion;                
    feed_mode_t feed_mode;               
    bool units_imperial;                 
    bool distance_incremental;           
    bool diameter_mode;                  
    //< uint8_t distance_arc;            //!< {G91.1} NOTE: Don't track. Only default supported.
    plane_select_t plane_select;         
    //< gc_ccomp_t cutter_comp;          //!< {G40,G41,G41.1,G42,G42.1} NOTE: Don't track. Only default (G40) supported.
    tool_offset_mode_t tool_offset_mode; 
    coord_system_t g5x_offset;           
#if ENABLE_PATH_BLENDING
    control_mode_t control;              
#endif
    program_flow_t program_flow;         
    coolant_state_t coolant;             
    spindle_t spindle[N_SYS_SPINDLE];    
    gc_override_flags_t override_ctrl;   
    cc_retract_mode_t retract_mode;      
    bool scaling_active;                 
    bool canned_cycle_active;
#if ENABLE_ACCELERATION_PROFILES
    float acceleration_factor;           
#endif
    float spline_pq[2];                  
 
    float tool_length_offset[N_AXIS];    
#if NGC_PARAMETERS_ENABLE
    float feed_rate;                     
    bool auto_restore;                   
#endif
} gc_modal_t;
 
typedef struct {
    override_t feed_rate;                   
    override_t rapid_rate;                  
    override_t spindle_rpm[N_SYS_SPINDLE];  
} gc_override_values_t;
 
typedef struct {
    gc_modal_t modal;
    gc_override_values_t override;
} gc_modal_snapshot_t;
 
typedef struct {
    float xyz[3];
    float delta;
    float dwell;
    float retract_position; 
    bool rapid_retract;
    bool spindle_off;
    cc_retract_mode_t retract_mode;
    bool change;
} gc_canned_t;
 
typedef enum {
    Taper_None = 0, 
    Taper_Entry,    
    Taper_Exit,     
    Taper_Both      
} gc_taper_type;
 
typedef struct {
    float pitch;
    float z_final;
    float peak;
    float initial_depth;
    float depth;
    float depth_degression;
    float main_taper_height;
    float end_taper_length;
    float infeed_angle;
    float cut_direction;
    uint_fast16_t spring_passes;
    gc_taper_type end_taper_type;
} gc_thread_data;
 
typedef struct {
    coord_data_t offset;    
    float radius;           
    tool_id_t tool_id;      
} tool_data_t;
 
typedef struct {
    const char *name;
    tool_data_t *data;
    pocket_id_t pocket;
} tool_table_entry_t;
 
typedef struct {
    tool_data_t tool;
    pocket_id_t pocket_id;
    char name[101];
} tool_pocket_t;
 
typedef struct {
    float angle;
    point_2d_t offsets;
} rotation_t;
 
#if NGC_PARAMETERS_ENABLE
 
typedef struct g66_arguments
{
    macro_call_t call;
    uint32_t call_level;
    gc_values_t values;
    parameter_words_t words;
    struct g66_arguments *prev;
} g66_arguments_t;
 
#endif
 
typedef struct {
    gc_modal_t modal;
    gc_canned_t canned;
    spindle_t *spindle;             
    float feed_rate;                
    float distance_per_rev;         
    float position[N_AXIS];         
#if ENABLE_PATH_BLENDING
    float path_tolerance;           
    float cam_tolerance;            
#endif
    uint32_t line_number;           
    tool_id_t tool_pending;         
#if NGC_EXPRESSIONS_ENABLE
    tool_id_t g43_pending;          
#endif
    bool file_run;                  
    bool file_stream;               
    bool is_laser_ppi_mode;
    bool is_rpm_rate_adjusted;
    bool tool_change;
    bool skip_blocks;               
    status_code_t last_error;       
    offset_id_t offset_id;          
    coord_data_t offset_queue[MAX_OFFSET_ENTRIES];
    bool g92_offset_applied;        
    coord_system_data_t g92_offset; 
    tool_data_t *tool;              
#if NGC_PARAMETERS_ENABLE
    g66_arguments_t *g66_args;      
#endif
} parser_state_t;
 
typedef struct {
    float xyz[N_AXIS]; 
    float ijk[N_AXIS]; 
} scale_factor_t;
 
extern parser_state_t gc_state;
 
typedef struct {
    non_modal_t non_modal_command;      
    tool_action_t tool_action;          
    override_mode_t override_command;   
    user_mcode_t user_mcode;            
    bool user_mcode_sync;               
    gc_modal_t modal;                   
    spindle_modal_t spindle_modal;
    gc_values_t values;                 
    parameter_words_t words;            
    output_command_t output_command;    
    uint32_t arc_turns;                 //
    parameter_words_t g65_words;        
#if NGC_PARAMETERS_ENABLE
    macro_call_t macro_call;
    modal_state_action_t state_action;  
#endif
#if N_AXIS > 3
    axes_signals_t rotary_wrap;
#endif
} parser_block_t;
 
 
static inline axes_signals_t gc_paramwords_to_axes (parameter_words_t p_words)
{
#if N_AXIS == 3
    return (axes_signals_t){ (uint8_t)(p_words.mask >> 24) };
#elif N_AXIS == 7
    return (axes_signals_t){ (uint8_t)(((p_words.mask >> 24) | ((p_words.mask << 2) & 0b00111000) | ((p_words.mask >> (21 - 6)) & 0b11000000)) & AXES_BITMASK) };
#else
    axes_signals_t axes = (axes_signals_t){ (uint8_t)(p_words.mask >> 24) };
 
  #ifdef A_AXIS
    axes.a = p_words.a;
  #endif
  #ifdef B_AXIS
    axes.b = p_words.b;
  #endif
  #ifdef C_AXIS
    axes.c = p_words.c;
  #endif
  #ifdef U_AXIS
    axes.u = p_words.u;
  #endif
  #ifdef V_AXIS
    axes.v = p_words.v;
  #endif
  #ifdef W_AXIS
    axes.w = p_words.w;
  #endif
 
    return axes;
#endif
}
 
// Initialize the parser
void gc_init (bool stop);
 
char *gc_normalize_block (char *block, status_code_t *status, char **message);
 
// Execute one block of rs275/ngc/g-code
status_code_t gc_execute_block (char *block);
 
// Sets g-code parser position in mm. Input in steps. Called by the system abort and hard
// limit pull-off routines.
#define gc_sync_position() system_convert_array_steps_to_mpos (gc_state.position, sys.position)
 
// Sets g-code parser and planner position in mm.
#define sync_position() plan_sync_position(); system_convert_array_steps_to_mpos (gc_state.position, sys.position)
 
// Set dynamic laser power mode to PPI (Pulses Per Inch)
// Driver support for pulsing the laser on signal is required for this to work.
// Returns true if driver uses hardware implementation.
bool gc_laser_ppi_enable (uint_fast16_t ppi, uint_fast16_t pulse_length);
parser_state_t *gc_get_state (void);
// Gets axes scaling state.
axes_signals_t gc_get_g51_state (void);
float *gc_get_scaling (void);
 
// Get current axis offset.
float gc_get_offset (uint_fast8_t idx, bool real_time);
 
char *gc_coord_system_to_str (coord_system_id_t id);
 
void gc_clear_output_commands (output_command_t *cmd);
 
spindle_t *gc_spindle_get (spindle_num_t spindle);
 
void gc_spindle_off (void);
void gc_coolant (coolant_state_t state);
 
void gc_set_tool_offset (tool_offset_mode_t mode, uint_fast8_t idx, int32_t offset);
plane_t *gc_get_plane_data (plane_t *plane, plane_select_t select);
axes_signals_t gc_claim_axis_words (parser_block_t *gc_block, axes_signals_t validate);
size_t gc_macro_get_pos (macro_id_t id, vfs_file_t *file);
 
#if NGC_PARAMETERS_ENABLE
parameter_words_t gc_get_g65_arguments (void);
bool gc_modal_state_restore (gc_modal_snapshot_t *snapshot);
#endif
 
#if ENABLE_ACCELERATION_PROFILES
float gc_get_accel_factor (uint8_t profile);
#endif
 
#endif // _GCODE_H_