g29_auto Namespace Reference

Functions
def	has_g1 (line)
def	find_axis (line, axis)
def	set_mima (line)
def	find_z (gcode, start_at_line=0)
def	z_parse (gcode, start_at_line=0, end_at_line=0)
def	get_lines (gcode, minimum)

Variables
string	folder = './'
string	my_file = 'test.gcode'
int	min_g1 = 3
int	max_g1 = 100000000
string	g29_keyword = 'g29'
string	output_file = folder + 'g29_' + my_file
string	input_file = folder + my_file
int	min_size = 40
int	probing_points = 3
int	min_x = 500
int	min_y = min_x
int	max_x = -500
int	max_y = max_x
float	last_z = 0.001
int	layer = 0
int	lines_of_g1 = 0
list	gcode = []
int	lines = 0
	start
	end
	offset_x = int((min_size - (max_x - min_x)) / 2 + 0.5)
	offset_y = int((min_size - (max_y - min_y)) / 2 + 0.5)
string	new_command
	out_file = open(output_file, 'w')
	in_file = open(input_file, 'r')

Function Documentation

has_g1()

def g29_auto.has_g1

(

line

)

def has_g1(line):
    return line[:2].upper() == "G1"
 
 
# find position in g1 (x,y,z)

find_axis()

def g29_auto.find_axis	(		line,
			axis
	)

def find_axis(line, axis):
    found = False
    number = ""
    for char in line:
        if found:
            if char == ".":
                number += char
            elif char == "-":
                number += char
            else:
                try:
                    int(char)
                    number += char
                except ValueError:
                    break
        else:
            found = char.upper() == axis.upper()
    try:
        return float(number)
    except ValueError:
        return None
 
 
# save the min or max-values for each axis

Here is the caller graph for this function:

set_mima()

def g29_auto.set_mima

(

line

)

def set_mima(line):
    global min_x, max_x, min_y, max_y, last_z
 
    current_x = find_axis(line, 'x')
    current_y = find_axis(line, 'y')
 
    if current_x is not None:
        min_x = min(current_x, min_x)
        max_x = max(current_x, max_x)
    if current_y is not None:
        min_y = min(current_y, min_y)
        max_y = max(current_y, max_y)
 
    return min_x, max_x, min_y, max_y
 
 
# find z in the code and return it

Here is the call graph for this function:

find_z()

def g29_auto.find_z	(		gcode,
			start_at_line = 0
	)

def find_z(gcode, start_at_line=0):
    for i in range(start_at_line, len(gcode)):
        my_z = find_axis(gcode[i], 'Z')
        if my_z is not None:
            return my_z, i
 
 

Here is the call graph for this function:

Here is the caller graph for this function:

z_parse()

def g29_auto.z_parse	(		gcode,
			start_at_line = 0,
			end_at_line = 0
	)

def z_parse(gcode, start_at_line=0, end_at_line=0):
    i = start_at_line
    all_z = []
    line_between_z = []
    z_at_line = []
    # last_z = 0
    last_i = -1
 
    while len(gcode) > i:
        try:
            z, i = find_z(gcode, i + 1)
        except TypeError:
            break
 
        all_z.append(z)
        z_at_line.append(i)
        temp_line = i - last_i -1
        line_between_z.append(i - last_i - 1)
        # last_z = z
        last_i = i
        if 0 < end_at_line <= i or temp_line >= min_g1:
            # print('break at line {} at heigth {}'.format(i, z))
            break
 
    line_between_z = line_between_z[1:]
    return all_z, line_between_z, z_at_line
 
 
# get the lines which should be the first layer

Here is the call graph for this function:

Here is the caller graph for this function:

get_lines()

def g29_auto.get_lines	(		gcode,
			minimum
	)

def get_lines(gcode, minimum):
    i = 0
    all_z, line_between_z, z_at_line = z_parse(gcode, end_at_line=max_g1)
    for count in line_between_z:
        i += 1
        if count > minimum:
            # print('layer: {}:{}'.format(z_at_line[i-1], z_at_line[i]))
            return z_at_line[i - 1], z_at_line[i]
 
 

Here is the call graph for this function:

Variable Documentation

folder

string g29_auto.folder = './'

my_file

string g29_auto.my_file = 'test.gcode'

min_g1

int g29_auto.min_g1 = 3

max_g1

int g29_auto.max_g1 = 100000000

g29_keyword

string g29_auto.g29_keyword = 'g29'

output_file

string g29_auto.output_file = folder + 'g29_' + my_file

input_file

string g29_auto.input_file = folder + my_file

min_size

int g29_auto.min_size = 40

probing_points

int g29_auto.probing_points = 3

min_x

g29_auto.min_x = 500

min_y

g29_auto.min_y = min_x

max_x

g29_auto.max_x = -500

max_y

g29_auto.max_y = max_x

last_z

float g29_auto.last_z = 0.001

layer

int g29_auto.layer = 0

lines_of_g1

int g29_auto.lines_of_g1 = 0

gcode

list g29_auto.gcode = []

lines

int g29_auto.lines = 0

start

g29_auto.start

end

g29_auto.end

offset_x

g29_auto.offset_x = int((min_size - (max_x - min_x)) / 2 + 0.5)

offset_y

g29_auto.offset_y = int((min_size - (max_y - min_y)) / 2 + 0.5)

new_command

string g29_auto.new_command

Initial value:

=  'G29 L{0} R{1} F{2} B{3} P{4}\n'.format(min_x,
                                                      max_x,
                                                      min_y,
                                                      max_y,
                                                      probing_points)

out_file

g29_auto.out_file = open(output_file, 'w')

in_file

g29_auto.in_file = open(input_file, 'r')