-
Notifications
You must be signed in to change notification settings - Fork 2
/
system.h
151 lines (119 loc) · 5.73 KB
/
system.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
/*
system.h - Header for system level commands and real-time processes
Part of Grbl
Copyright (c) 2014 Sungeun K. Jeon
Grbl 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.
Grbl 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 Grbl. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef system_h
#define system_h
// Define system header files and standard libraries used by Grbl
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include <util/delay.h>
#include <math.h>
#include <inttypes.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
// Define Grbl configuration and shared header files
#include "config.h"
#include "defaults.h"
#include "cpu_map.h"
#include "nuts_bolts.h"
// Define system executor bit map. Used internally by runtime protocol as runtime command flags,
// which notifies the main program to execute the specified runtime command asynchronously.
// NOTE: The system executor uses an unsigned 8-bit volatile variable (8 flag limit.) The default
// flags are always false, so the runtime protocol only needs to check for a non-zero value to
// know when there is a runtime command to execute.
#define EXEC_RUNTIME_REPORT bit(0) // bitmask 00000001
#define EXEC_CYCLE_START bit(1) // bitmask 00000010
#define EXEC_CYCLE_STOP bit(2) // bitmask 00000100
#define EXEC_FEED_HOLD bit(3) // bitmask 00001000
#define EXEC_RESET bit(4) // bitmask 00010000
#define EXEC_ALARM bit(5) // bitmask 00100000
#define EXEC_CRIT_EVENT bit(6) // bitmask 01000000
//
#define REQUEST_STATUS_REPORT bit(0)
#define REQUEST_LIMIT_REPORT bit(1)
#define REQUEST_COUNTER_REPORT bit(2)
#define REQUEST_VOLTAGE_REPORT bit(3)
// Define system state bit map. The state variable primarily tracks the individual functions
// of Grbl to manage each without overlapping. It is also used as a messaging flag for
// critical events.
#define STATE_IDLE 0 // Must be zero. No flags.
#define STATE_ALARM bit(0) // In alarm state. Locks out all g-code processes. Allows settings access.
#define STATE_CHECK_MODE bit(1) // G-code check mode. Locks out planner and motion only.
#define STATE_HOMING bit(2) // Performing homing cycle
#define STATE_QUEUED bit(3) // Indicates buffered blocks, awaiting cycle start.
#define STATE_CYCLE bit(4) // Cycle is running
#define STATE_HOLD bit(5) // Executing feed hold
// #define STATE_JOG bit(6) // Jogging mode is unique like homing.
// Define global system variables
typedef struct {
uint8_t abort; // System abort flag. Forces exit back to main loop for reset.
uint8_t state; // Tracks the current state of Grbl.
uint8_t auto_start; // Planner auto-start flag. Toggled off during feed hold. Defaulted by settings.
uint8_t eol_flag; //flag for reporting linenumber;
int32_t position[N_AXIS]; // Real-time machine (aka home) position vector in steps.
// NOTE: This may need to be a volatile variable, if problems arise.
int32_t probe_position[N_AXIS]; // Last probe position in machine coordinates and steps.
} system_t;
extern system_t sys;
typedef struct {
volatile uint8_t execute; // Global system runtime executor bitflag variable. See EXEC bitmasks.
volatile uint8_t probe_state; // Probing state value. Used to coordinate the probing cycle with stepper ISR.
volatile uint8_t limits; //limit
volatile uint8_t report_rqsts; //requestsd reports
} sys_flags_t;
extern volatile sys_flags_t sysflags;
#ifndef UNPROTECTED_VOLATILES
#define SYS_EXEC GPIOR0
#else
#define SYS_EXEC sysflags.execute
#endif
extern uint32_t masterclock; //long running clock w/ 1ms resolution. rolls over every 49.7 days
// Initialize the serial protocol
void system_init();
// Executes an internal system command, defined as a string starting with a '$'
uint8_t system_execute_line(char *line);
// Checks and executes a runtime command at various stop points in main program
void system_execute_runtime();
// Execute the startup script lines stored in EEPROM upon initialization
void system_execute_startup(char *line);
// * Utilities for line numbeirng *
// NOTE: Max line number is defined by the g-code standard to be 99999. It seems to be an
// arbitrary value, and some GUIs may require more. So grbl increased it based on a max safe
// value when converting a float (7.2 digit precision)s to an integer.
// But We don't need such a big value, and we do need the high bit free
//#define MAX_LINE_NUMBER 9999999
#define LINENUMBER_EMPTY_BLOCK 0x8000 //the other bit, used as a flag
#define LINENUMBER_SPECIAL 0x4000
#define LINENUMBER_MAX (LINENUMBER_SPECIAL-1)
typedef uint16_t linenumber_t; //resize back to int32 for bigger numbers
void linenumber_init();
uint8_t linenumber_insert(linenumber_t line_number);
linenumber_t linenumber_get();
linenumber_t linenumber_peek();
enum {
time_STEP_ISR,
time_HOMING,
time_PROBE,
time_CLOCK
};
#define ACTIVE_TIMER time_STEP_ISR
#define TIME_OFF(tid) (((tid)==ACTIVE_TIMER)?(TIMING_PORT|=TIMING_MASK):0)
#define TIME_ON(tid) (((tid)==ACTIVE_TIMER)?(TIMING_PORT&=~TIMING_MASK):0)
#define TIME_TOGGLE(tid) (((tid)==ACTIVE_TIMER)?(TIMING_PIN|=TIMING_MASK):0)
#endif