system.h

Go to the documentation of this file.

/*
  system.h - Header for system level commands and real-time processes
 
  Part of grblHAL
 
  Copyright (c) 2017-2025 Terje Io
  Copyright (c) 2014-2016 Sungeun K. Jeon for Gnea Research LLC
 
  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 _SYSTEM_H_
#define _SYSTEM_H_
 
#include "gcode.h"
#include "probe.h"
#include "alarms.h"
#include "messages.h"
#if NGC_EXPRESSIONS_ENABLE
#include "vfs.h"
#endif
 
#define EXEC_STATUS_REPORT      bit(0)
#define EXEC_CYCLE_START        bit(1)
#define EXEC_CYCLE_COMPLETE     bit(2)
#define EXEC_FEED_HOLD          bit(3)
#define EXEC_STOP               bit(4)
#define EXEC_RESET              bit(5)
#define EXEC_SAFETY_DOOR        bit(6)
#define EXEC_MOTION_CANCEL      bit(7)
#define EXEC_MOTION_CANCEL_FAST bit(7) // Permanently enabled for now
#define EXEC_SLEEP              bit(9)
#define EXEC_TOOL_CHANGE        bit(10)
#define EXEC_PID_REPORT         bit(11)
#define EXEC_GCODE_REPORT       bit(12)
#define EXEC_TLO_REPORT         bit(13)
#define EXEC_RT_COMMAND         bit(14)
#define EXEC_DOOR_CLOSED        bit(15)
 
 
#define STATE_IDLE          0      
#define STATE_ALARM         bit(0) 
#define STATE_CHECK_MODE    bit(1) 
#define STATE_HOMING        bit(2) 
#define STATE_CYCLE         bit(3) 
#define STATE_HOLD          bit(4) 
#define STATE_JOG           bit(5) 
#define STATE_SAFETY_DOOR   bit(6) 
#define STATE_SLEEP         bit(7) 
#define STATE_ESTOP         bit(8) 
#define STATE_TOOL_CHANGE   bit(9) 
 
 
typedef enum {
    SystemState_Idle = 0,
    SystemState_Alarm = 1,
    SystemState_CheckMode = 2,
    SystemState_Homing = 3,
    SystemState_Cycle = 4,
    SystemState_Hold = 5,
    SystemState_Jog = 6,
    SystemState_DoorOpen = 7,
    SystemState_Sleep = 8,
    SystemState_EStop = 9,
    SystemState_ToolChange = 10,
    SystemState_Undefined = 255
} __attribute__ ((__packed__)) system_state_t;
 
#ifdef ARDUINO
 
typedef enum  {
    Mode_Standard = 0,      
    Mode_Laser,             
    Mode_Lathe              
} machine_mode_t;
 
#else
 
typedef uint8_t machine_mode_t;
 
enum machine_mode_t {
    Mode_Standard = 0,      
    Mode_Laser,             
    Mode_Lathe              
};
 
#endif
 
typedef enum {
    Parking_DoorClosed = 0, 
    Parking_DoorAjar,       
    Parking_Retracting,     
    Parking_Cancel,         
    Parking_Resuming        
} parking_state_t;
 
typedef enum {
    Hold_NotHolding = 0,    
    Hold_Complete = 1,      
    Hold_Pending = 2        
} hold_state_t;
 
typedef uint_fast16_t rt_exec_t; 
typedef uint_fast16_t sys_state_t; 
 
// Define step segment generator state flags.
typedef union {
    uint8_t flags;
    struct {
        uint8_t end_motion         :1,
                execute_hold       :1,
                execute_sys_motion :1,
                update_spindle_rpm :1,
                unassigned         :4;
    };
} step_control_t;
 
// NOTE: the pin_function_t enum must be kept in sync with any changes!
typedef union {
    uint16_t bits;
    uint16_t mask;
    uint16_t value;
    struct {
        uint16_t reset                :1,
                 feed_hold            :1,
                 cycle_start          :1,
                 safety_door_ajar     :1,
                 block_delete         :1,
                 stop_disable         :1, 
                 e_stop               :1,
                 probe_disconnected   :1,
                 motor_fault          :1,
                 motor_warning        :1,
                 limits_override      :1,
                 single_block         :1,
                 tls_overtravel       :1, 
                 probe_overtravel     :1, 
                 probe_triggered      :1, 
                 deasserted           :1; 
    };
} control_signals_t;
 
// Define spindle stop override control states.
typedef union {
    uint8_t value;
    struct {
        uint8_t enabled       :1,
                initiate      :1,
                restore       :1,
                restore_cycle :1,
                unassigned    :4;
    };
} spindle_stop_t;
 
#ifdef PID_LOG
 
typedef struct {
    uint_fast16_t idx;
    float setpoint;
    float t_sample;
    float target[PID_LOG];
    float actual[PID_LOG];
} pid_data_t;
 
#endif
 
typedef enum {
    Report_ClearAll = 0,
    Report_MPGMode = (1 << 0),
    Report_Scaling = (1 << 1),
    Report_Homed   = (1 << 2),
    Report_LatheXMode = (1 << 3),
    Report_Spindle = (1 << 4),
    Report_Coolant = (1 << 5),
    Report_Overrides = (1 << 6),
    Report_Tool = (1 << 7),
    Report_WCO = (1 << 8),
    Report_GWCO = (1 << 9),
    Report_ToolOffset = (1 << 10),
    Report_M66Result = (1 << 11),
    Report_PWM = (1 << 12),
    Report_Motor = (1 << 13),
    Report_Encoder = (1 << 14),
    Report_TLOReference = (1 << 15),
    Report_Fan = (1 << 16),
    Report_SpindleId = (1 << 17),
    Report_ProbeId = (1 << 18),
    Report_DistanceToGo = (1 << 19),
    Report_ForceWCO = (1 << 29),
    Report_CycleStart = (1 << 30),
    Report_All = 0x8003FFFF
} report_tracking_t;
 
typedef union {
    uint32_t value;
    struct {
        uint32_t mpg_mode       :1, 
                 scaling        :1, 
                 homed          :1, 
                 xmode          :1, 
                 spindle        :1, 
                 coolant        :1, 
                 overrides      :1, 
                 tool           :1, 
                 wco            :1, 
                 gwco           :1, 
                 tool_offset    :1, 
                 m66result      :1, 
                 pwm            :1, 
                 motor          :1, 
                 encoder        :1, 
                 tlo_reference  :1, 
                 fan            :1, 
                 spindle_id     :1, 
                 probe_id       :1, 
                 distance_to_go :1, 
                 unassigned     :9, //
                 force_wco      :1, 
                 cycle_start    :1, 
                 all            :1; 
    };
} report_tracking_flags_t;
 
typedef struct {
    override_t feed_rate;           
    override_t rapid_rate;          
    override_t spindle_rpm;         
    spindle_stop_t spindle_stop;    
    gc_override_flags_t control;    
} overrides_t;
 
typedef union {
    uint8_t flags;
    struct {
        uint8_t feedrate :1,
                coolant  :1,
                spindle  :1,
                unused   :5;
    };
} system_override_delay_t;
 
typedef union {
    uint16_t value;
    struct {
        uint16_t mpg_mode                :1, 
                 probe_succeeded         :1, 
                 soft_limit              :1, 
                 exit                    :1, 
                 block_delete_enabled    :1, 
                 feed_hold_pending       :1,
                 optional_stop_disable   :1,
                 single_block            :1, 
                 keep_input              :1, 
                 auto_reporting          :1, 
                 travel_changed          :1, 
                 is_homing               :1,
                 unused                  :4;
    };
} system_flags_t;
 
typedef struct {
    control_signals_t control;
    limit_signals_t limits;
} signal_event_t;
 
typedef struct {
    coord_data_t min;
    coord_data_t max;
} work_envelope_t;
 
// NOTE: probe_position and position variables may need to be declared as volatiles, if problems arise.
typedef struct system {
    bool abort;                             
    bool cancel;                            
    bool suspend;                           
    bool position_lost;                     
    bool reset_pending;                     
    bool blocking_event;                    
    volatile bool steppers_deenergize;      
    alarm_code_t alarm_pending;             
    volatile system_flags_t flags;                   
    step_control_t step_control;            
    axes_signals_t homing_axis_lock;        
    axes_signals_t homing;                  
    overrides_t override;                   
    system_override_delay_t override_delay; 
    report_tracking_flags_t report;         
    parking_state_t parking_state;          
    hold_state_t holding_state;             
    coord_system_id_t probe_coordsys_id;    
    int32_t probe_position[N_AXIS];         
    volatile probing_state_t probing_state; 
    volatile rt_exec_t rt_exec_state;       
    volatile uint_fast16_t rt_exec_alarm;   
    int32_t var5399;                        
#ifdef PID_LOG
    pid_data_t pid_log;
#endif
 
    axes_signals_t homed;                   
    float home_position[N_AXIS];            
    work_envelope_t work_envelope;          
    axes_signals_t tlo_reference_set;       
    int32_t tlo_reference[N_AXIS];          
 
    alarm_code_t alarm;                     
    bool cold_start;                        
    bool ioinit_pending;
    bool driver_started;                    
    bool mpg_mode;                          
    signal_event_t last_event;              
    int32_t position[N_AXIS];               
    axes_signals_t hard_limits; 
    axes_signals_t soft_limits; 
} system_t;
 
typedef status_code_t (*sys_command_ptr)(sys_state_t state, char *args);
typedef const char *(*sys_help_ptr)(const char *command);
 
typedef union {
    uint8_t flags;
    struct {
        uint8_t noargs         :1, 
                allow_blocking :1, 
                help_fn        :1,
                unused         :5;
    };
} sys_command_flags_t;
 
typedef struct
{
    const char *command;
    sys_command_ptr execute;
    sys_command_flags_t flags;
    union {
        const char *str;
        sys_help_ptr fn;
    } help;
} sys_command_t;
 
typedef struct sys_commands_str {
    const uint8_t n_commands;
    const sys_command_t *commands;
    struct sys_commands_str *next;
    struct sys_commands_str *(*on_get_commands)(void); 
} sys_commands_t;
 
extern system_t sys;
 
status_code_t system_execute_line (char *line);
void system_execute_startup (void *data);
void system_flag_wco_change (void);
void system_convert_array_steps_to_mpos (float *position, int32_t *steps);
bool system_xy_at_fixture (coord_system_id_t id, float tolerance);
void system_raise_alarm (alarm_code_t alarm);
void system_init_switches (void);
void system_command_help (void);
void system_output_help (const sys_command_t *commands, uint32_t num_commands);
void system_register_commands (sys_commands_t *commands);
 
void system_clear_tlo_reference (axes_signals_t homing_cycle);
void system_add_rt_report (report_tracking_t report);
report_tracking_flags_t system_get_rt_report_flags (void);
 
// Special handlers for setting and clearing grblHAL's real-time execution flags.
#define system_set_exec_state_flag(mask) hal.set_bits_atomic(&sys.rt_exec_state, (mask))
#define system_clear_exec_state_flag(mask) hal.clear_bits_atomic(&sys.rt_exec_state, (mask))
#define system_clear_exec_states() hal.set_value_atomic(&sys.rt_exec_state, 0)
#define system_set_exec_alarm(code) hal.set_value_atomic(&sys.rt_exec_alarm, (uint_fast16_t)(code))
#define system_clear_exec_alarm() hal.set_value_atomic(&sys.rt_exec_alarm, 0)
 
void control_interrupt_handler (control_signals_t signals);
 
#endif