Programa GCode (configurable) para Mach3: desvasta volumen alisando sucesivamente plano XY

Algo tan simple como hacer un hueco de forma rectangular (o repetido/panelizado a lo largo de los ejes X e Y), o un corte lineal (de cierto espesor), o alisar una superficie con una máquina de CNC. Es simple, pero bueno, uno a veces tiene necesidades y escribe el programa una vez, dos veces, y luego se da cuenta que Mach3 es un excelente programa para controlar una máquina de CNC, pero lamentablemente no permite realizar ciertas cosas extremadamente útiles como asignación de nombres simbólicos a las variables ni construcciones condicionales.

Por supuesto, estoy considerando que los programas son escritos a mano (tal como suelo hacer yo cuando necesito hacer mecanizaciones geométricamente simples). De mas está decir, también se pueden generar los programas utilizando modelado 3D mediante un software CAD, aunque como mencioné recién, si la geometría es simple, el código resultante de escribirlo manualmente queda bastante compacto y lindo. Frente a estas situaciones incómodas desde el punto de vista del programador (principalmente la de no poder asignar nombres simbólicos), para aliviar un poco la carga de tener que escribir un nuevo programa para cada situación o necesidad, aquí se permite generar el gcode (de la realización de un array de huecos rectangulares, es decir, panelizados) ajustando ciertos parámetros.

Consideraciones para configurar correctamente las variables:

El usuario setea las coordenadas de los vértices del rectángulo (la zona a desvastar), luego, el programa en base al diámetro de la herramienta calcula el camino requerido de esta.

Reserva de Variables (para contar loops): desde #1000

No requiero específicamente "declarar" las variables que voy a usar, pero sí preciso saber que debo reservar el espacio en memoria para dicha variable y no pisarlo con otra. Concretamente, voy a hacer uso de las siguientes variables (no voy a generar código para esta "reserva", sino que es para tenerlo en cuenta al momento de asignarle un número de parámetro a cada variable). Repito, la siguiente enumeración no es código de programa, sino que es dicho con el único fin de "acordarme yo" que estas zonas de memoria las voy a usar para una finalidad ya establecida.

contador_linea_x = #1000 //Cuenta las múltiples iteraciones del movimiento a lo largo del eje X yendo y viniendo que va a tener que hacer para alisar el plano XY en una determinada posición z
contador_plano_z = #1001 //Cuenta iteraciones sobre plano Z
contador_panel_x = #1002 //Cuenta iteraciones en panelizado X
contador_panel_y = #1003 //Cuenta iteraciones en panelizado Y

Reserva de Subrutinas (que no son loops): desde O2000

En gcode, la llamada a una subrutina tiene 2 formas:

Se ejecuta 1 única vez.
Se ejecuta N veces (loop).

Para los loops ya he reservado memoria para las variables "contadores" y utilizaré ese mismo valor del address para nombrar a la subrutinas que son loops (ya que a cada subrutina, el programa debe asignarle un número, y yo haré que ese número sea igual a mi variable "contador" para ser mas práctico). Pero en el caso de las subrutinas que se invocan una única vez, dado que no tengo variable "contador", entonces debo asignarle un número de subrutina seleccionado de una manera alternativa.

A continuación se reservan zonas de memoria para las subrutinas que no son loops (ya que como dije anteriormente, para los loops se usa el mismo address que el "contador" que le corresponde). No se genera código en esta instancia, pero sí "me acuerdo" que las siguientes zonas de memoria van a ser ocupadas.

subrutina_perimetro = O2000 //Reserva de address para "subrutina_perimetro"

Seteo Constantes (hardcoded)

Las constantes a continuación no pertenecen al código del programa ya que no es necesario memorizarlos dado que estos valores son tomados en el momento de la escritura del código fuente únicamente. Aquí son definidos valores constantes que a lo largo del programa será necesario escribir. Todas las coordenadas espaciales se encuentran en unidades de mm.

Puede hacer click en parámetros coloreados en azul para modificarlos, y automáticamente la página va a refrescar y mostrar el resultado acorde con el valor ingresado.

diametroHerramienta = 3 //unidad=mm, a partir de este valor intenta minimizar la cantidad de pasadas sobre el eje X para ir desvastando un plano XY por completo dado un Z=constante.
feedRateSobrevuelo = 1000 //Variable de feedrate, normalmente no requiere cambio cuando se encuentra el feedrate ideal para determinado material
feedRateMecanizacion = 100 //Variable de feedrate, normalmente no requiere cambio cuando se encuentra el feedrate ideal para determinado material
posIni_x = 0 //Coordenada X inicial y final de la herramienta. Empieza y termina en el mismo lugar.
posIni_y = 0 //Coordenada Y inicial y final de la herramienta. Empieza y termina en el mismo lugar.
posIni_z = 0 //Coordenada Z inicial y final de la herramienta. Empieza y termina en el mismo lugar.
ZmecanizadoIni = 0 //Plano comienzo de mecanización
ZmecanizadoFin = -4 //Plano fin mecanización
ZmecanizadoDelta = -1 //Tamaño de pasos en mecanización
Zsobrevuelo = 10 //Plano Z "seguro" para que la herramienta se mueva
p00_x = 10 //Punto que delimita rectángulo sobre el cual la herramienta va a desvastar, coordenada X inferior izquierda
p00_y = 20 //Punto que delimita rectángulo sobre el cual la herramienta va a desvastar, coordenada Y inferior izquierda
p11_x = 20 //Punto que delimita rectángulo sobre el cual la herramienta va a desvastar, coordenada X superior derecha
p11_y = 30 //Punto que delimita rectángulo sobre el cual la herramienta va a desvastar, coordenada Y superior derecha
superposicion_y = 0.5 //Valor mínimo. Para desvastar plano XY dibuja líneas a lo largo del eje X separadas una distancia igual a "diametroHerramienta". Conviene que exista cierta superposicion entre las pasadas.
panelSize_x = 2 //Cantidad repeticiones eje X, para panelizado
panelSize_y = 3 //Cantidad repeticiones eje Y, para panelizado
panelDelta_x = 20 //Separación de repeticiones eje X
panelDelta_y = 20 //Separación de repeticiones eje Y

Constantes Calculadas (hardcoded)

Las variables a continuación tampoco pertenecen al código del programa ya que aquí simplemente son calculados valores constantes que a lo largo del programa será necesario usar, pero no se almacenan en memoria, sino que al momento de escribir el programa se utilizan. No son para que el usuario ajuste el valor, ya que se calculan automaticamente partiendo de los datos previamente ingresados.

nPasadasPlano_z = 5 //Valor calculado=round[[ZmecanizadoFin-ZmecanizadoIni]/ZmecanizadoDelta]+1
nPasadasEje_x = 1 //Valor calculado=floor[[[y-y0-diamHerramienta]/[diamHerramienta-superposicion]]/2]

El resultado de la variable "nPasadasEje_x" determina si es necesario que la herramienta pase por el medio del área del plano XY (nPasadasEje_x>0), o si con realizar solamente un recorrido por el perímetro alcanza (este caso se da solamente si [y-y0<=2*diamHerramienta-superposicion])

Funcion "main"

G90 (absolute coords)
G21 (mm mode)
M3 (spindle on)
F1000 ("feedRateSobrevuelo")
G01 Z[10] (Move: "Zsobrevuelo")
#1003=0 ("contador_panel_y": inicializacion variable)
M98 P1003 L3 (Subrutina_panel_y)
G01 X[0] Y[0] (Move: posicion inicial XY)
G01 Z[0] (Move: posicion inicial Z)
M5 (Spindle off)
M30 (Program end and rewind)

Subrutina "Panel Y"

O1003 (Subrutina_panel_y)
#1002=0 ("contador_panel_x": inicializacion variable)
M98 P1002 L2 (Subrutina_panel_x)
#1003=[#1003+1] (contador_panel_y++)
M99 (Fin subrutina)

Subrutina "Panel X"

O1002 ("subrutina_panel_x")
#1001=0 ("contador_plano_z": inicializacion variable)
M98 P1001 L5 ("subrutina_plano_z")
G01 Z[10] ("Zsobrevuelo": move)
#1002=[#1002+1] (contador_panel_x++)
M99 (Fin subrutina)

Subrutina "Plano Z"

O1001 ("subrutina_plano_z")
M98 P2000 ("subrutina_perimetro")
#1000=0 ("contador_linea_x": inicializacion variable)
M98 P1000 L1 ("subrutina_linea_x")
#1001=[#1001+1] (contador_plano_z++)
M99 (Fin subrutina)

Subrutina "Perimetro"

O2000 ("subrutina_perimetro")
G01 X[11.5+#1002*20] Y[21.5+#1003*20] ("p00": move XY)
G01 Z[0+#1001*-1] (move: "Z")
F100 ("feedRateMecanizacion")
G01 X[18.5+#1002*20] Y[21.5+#1003*20] ("p10": move XY)
G01 X[18.5+#1002*20] Y[28.5+#1003*20] ("p11": move XY)
G01 X[11.5+#1002*20] Y[28.5+#1003*20] ("p01": move XY)
G01 X[11.5+#1002*20] Y[21.5+#1003*20] ("p00": move XY)
M99 (Fin subrutina)

Subrutina "Linea X"

O1000 ("subrutina_linea_x")
F1000 ("feedRateSobrevuelo")
G01 X[11.5+#1002*20] Y[23.8333333333+#1003*20+#1000*2.33333333333] ("linea_X_p00": move XY)
F100 ("feedRateMecanizacion")
G01 X[18.5+#1002*20] Y[23.8333333333+#1003*20+#1000*2.33333333333] ("linea_X_p10": move XY)
F1000 ("feedRateSobrevuelo")
G01 X[18.5+#1002*20] Y[26.1666666667+#1003*20+#1000*2.33333333333] ("linea_X_p11": move XY)
F100 ("feedRateMecanizacion")
G01 X[11.5+#1002*20] Y[26.1666666667+#1003*20+#1000*2.33333333333] ("linea_X_p01": move XY)
F1000 ("feedRateSobrevuelo")
#1000=[#1000+1] (contador_linea_x++)
M99 (Fin subrutina)

Resultado: código gcode completo

(Parámetros ingresados para la generación del presente código)
(------------------------------------------------------------)
(diametroHerramienta = 3)
(feedRateSobrevuelo = 1000)
(feedRateMecanizacion = 100)
(posIni_x = 0)
(posIni_y = 0)
(posIni_z = 0)
(ZmecanizadoIni = 0)
(ZmecanizadoFin = -4)
(ZmecanizadoDelta = -1)
(Zsobrevuelo = 10)
(p00_x = 10)
(p00_y = 20)
(p11_x = 20)
(p11_y = 30)
(superposicion_y = 0.5)
(panelSize_x = 2)
(panelSize_y = 3)
(panelDelta_x = 20)
(panelDelta_y = 20)

(Funcion "main")
(--------------)
G90 (absolute coords)
G21 (mm mode)
M3 (spindle on)
F1000 ("feedRateSobrevuelo")
G01 Z[10] (Move: "Zsobrevuelo")
#1003=0 ("contador_panel_y": inicializacion variable)
M98 P1003 L3 (Subrutina_panel_y)
G01 X[0] Y[0] (Move: posicion inicial XY)
G01 Z[0] (Move: posicion inicial Z)
M5 (Spindle off)
M30 (Program end and rewind)

(Subrutina "Panel Y")
(-------------------)
O1003 (Subrutina_panel_y)
#1002=0 ("contador_panel_x": inicializacion variable)
M98 P1002 L2 (Subrutina_panel_x)
#1003=[#1003+1] (contador_panel_y++)
M99 (Fin subrutina)

(Subrutina "Panel X")
(-------------------)
O1002 ("subrutina_panel_x")
#1001=0 ("contador_plano_z": inicializacion variable)
M98 P1001 L5 ("subrutina_plano_z")
G01 Z[10] ("Zsobrevuelo": move)
#1002=[#1002+1] (contador_panel_x++)
M99 (Fin subrutina)

(Subrutina "Plano Z")
(-------------------)
O1001 ("subrutina_plano_z")
M98 P2000 ("subrutina_perimetro")
#1000=0 ("contador_linea_x": inicializacion variable)
M98 P1000 L1 ("subrutina_linea_x")
#1001=[#1001+1] (contador_plano_z++)
M99 (Fin subrutina)

(Subrutina "Perimetro")
(---------------------)
O2000 ("subrutina_perimetro")
G01 X[11.5+#1002*20] Y[21.5+#1003*20] ("p00": move XY)
G01 Z[0+#1001*-1] (move: "Z")
F100 ("feedRateMecanizacion")
G01 X[18.5+#1002*20] Y[21.5+#1003*20] ("p10": move XY)
G01 X[18.5+#1002*20] Y[28.5+#1003*20] ("p11": move XY)
G01 X[11.5+#1002*20] Y[28.5+#1003*20] ("p01": move XY)
G01 X[11.5+#1002*20] Y[21.5+#1003*20] ("p00": move XY)
M99 (Fin subrutina)

(Subrutina "Linea X")
(-------------------)
O1000 ("subrutina_linea_x")
F1000 ("feedRateSobrevuelo")
G01 X[11.5+#1002*20] Y[23.8333333333+#1003*20+#1000*2.33333333333] ("linea_X_p00": move XY)
F100 ("feedRateMecanizacion")
G01 X[18.5+#1002*20] Y[23.8333333333+#1003*20+#1000*2.33333333333] ("linea_X_p10": move XY)
F1000 ("feedRateSobrevuelo")
G01 X[18.5+#1002*20] Y[26.1666666667+#1003*20+#1000*2.33333333333] ("linea_X_p11": move XY)
F100 ("feedRateMecanizacion")
G01 X[11.5+#1002*20] Y[26.1666666667+#1003*20+#1000*2.33333333333] ("linea_X_p01": move XY)
F1000 ("feedRateSobrevuelo")
#1000=[#1000+1] (contador_linea_x++)
M99 (Fin subrutina)