• Home
• G-Code Programming
• G-Code Macro Programming

G-Code Macro Programming

G-Code Macro programming enables logic statements and variable access for creating dynamic programs, offering many features similar to BASIC-style programming languages or IEC61131 Structured Text.

In general, all logic here is done as pre-processor before G-Code processing

Thus, the following two situations are equivalent to the core system

		
			#200
			=
			1000
			G01
			X10
			Y10
			F#200
		
	

and

		
			G01
			X10
			Y10
			F1000
		
	

• Clear use of spacing is recommended for more readable math
• Avoid too many operators on a line for readability

Operator Precedence and Associativity

• Standard math order of operations generally, but when in doubt add [ ] to group operations in an easier to read order
• https://learn.microsoft.com/en-us/cpp/c-language/precedence-and-order-of-evaluation?view=msvc-170

Langauge Keywords

GCode Variables

See: G-Code Variables

Program Flow

Conditional Operators

Boolean Operators

Bitwise Operators

Math Operators

See: Math Operators

Math Functions

See: Math Functions

Trig Functions

• Trigonometric functions always use degrees (not radians)
• Allowed spacing formats:
  
  - SIN[45] == SIN[ 45 ] == SIN [45] == SIN [ 45 ]

Multi-line statements are not supported

		
			IF[
			SIN[#5]
			+
			45
			>
			COS[#6]]  // this must be on the same line as 'IF' above
		
	

Conditional Operators (EQ/LT/GT/GE/LE/NE)

Indirect Variable References

Since a variable may have an integer value and # registers are identified by integers, the value of a register may be used as a pointer to a # register.

A variable pointer to a # register is formed by the # followed by an expression that is contained in square brackets [ ] that resolves to an integer value. Functions are not allowed within the [ ] brackets when using indirect variable referencing.

For example:

		
			#100
			=
			50
			#[#100] =
			77
			(#100 points to #50, thus setting #50 to 77)
			#[#100
			+
			2] =
			85
			(this is an error. functions and operations aren't allowed for indirect variable referencing)
			#101
			=
			#100
			+
			2(instead, use a temporary intermediate variable, #101 is now 52)
			#[#101] =
			85
			(now #52 can be written to)
		
	

It is generally recommended to always macro variables with a tolerance when working with any non-integer data. This also applies to IF/WHILE comparison checks.

For example, a program might use either an intermediate variable and apply either aROUND (to closest), FIX (always rounds down), or FUP (always rounds up) operators to ensure that the expression resolves to the desired integer.

For example:

		
			// for indirect variable references to ensure proper integer indexing
			
			#100
			=
			0.6
			/
			2
			*
			10(#100 is ~2.9999999).
			#[#100] =
			77
			(#100 is auto rounded to 3, 77 is written to #3)
			#101
			=
			5.4
			(#101 is 5.4)
			#102
			=
			FIX[#101](5.4 is truncated to 5)
			#[#102] =
			47
			(47 is written to #5)
			#103
			=
			FUP[#101](5.4 is rounded up to 6)
			#[#103] =
			24
			(24 is written to #6)
			#104
			=
			ROUND[#101](5.4 is rounded to the closest integer 5)
			#[#104] =
			35
			(35 is written to #5)
			#[#101] =
			77
			(error, 5.4 is outside the automatic rounding tolerance)