Malla nivelación de cama

Ahora que ya tenemos nuestra cama correctamente nivelada es el turno de hacer una malla con medidas de nuestra cama para poder ajustar/minimizar cualquier desviación de la misma y que nuestras primeras capas sean siempre lo más perfectas posible.

Es muy importante que, tal como explicamos en el punto anterior de nivelación manual de cama tengamos hecho la nivelación explicada así como el Z-Tilt en el caso que tengamos varios motores en Z independientes.

Podéis encontrar la documentación oficial de Klipper:

Configuración del mallado de cama

Para poder realizar un mallado de nivelación de nuestra cama es fundamental tener en cuenta que antes deberemos de definir las características.

Dentro de nuestro printer.cfg crearemos, si no la tenemos ya, la sección [bed_mesh] a continuación os vamos a mostrar un ejemplo:

[bed_mesh]
speed: 300
horizontal_move_z: 10

mesh_min: 40, 40
mesh_max: 210,210

fade_start: 0.6
fade_end: 10.0
probe_count: 5,5
algorithm: bicubic

En la configuración de [bed_mesh] de ejemplo podremos encontrar los siguientes parámetros importantes:

  • speed, creo que es autoexplicativo y hace referencia a la velocidad de nuestra máquina durante el proceso

  • mesh_min y mesh_max son las coordenadas de inicio y final del área donde realizaremos nuestro mallado con respecto a nuestro sensor... tenemos que tener en cuenta que estos puntos de inicio y final permitan que nuestro sensor pueda llegar a hacer las medidas si no nos indicará problemas al aplicar el proceso de mallado indicando, por ejemplo, que nos hemos salido de las coordenadas

Tenemos una pequeña macro que, en base a la configuración de nuestro cfg y el margen que queramos añadir de seguridad, nos va a sugerir los valores mesh_min y mesh_max de una forma sencilla:

# More info https://3dwork.gitbook.io/3dwork.io/klipper/empezamos/malla-nivelacion-de-cama-klipper
### CALCULATE_BED_MESH - Helps to calculate bed mesh boundaries automatically

[gcode_macro CALCULATE_BED_MESH]
description: Calculate bed_mesh boundaries automatically based on your bltouch/probe config
gcode:
  {% set BED_MESH_MARGIN = params.BED_MESH_MARGIN|default(10)|float %}
  # Get Printer built volume dimensions
  {% set X_MAX = printer.toolhead.axis_maximum.x|default(230)|float %}
  {% set Y_MAX = printer.toolhead.axis_maximum.y|default(230)|float %}
  # Get Nothing/BLTouch/Probe X and Y offsets
  {% set X_OFFSET = 0.0 |float %}
  {% set Y_OFFSET = 0.0 |float %}
  #Get BLTouch/Probe X and Y offsets
  {% if printer.configfile.config["bltouch"] is defined %}
    {% set X_OFFSET = (printer.configfile.settings.bltouch.x_offset if printer.configfile.settings.bltouch.x_offset is defined else X_OFFSET)|float %}
    {% set Y_OFFSET = (printer.configfile.settings.bltouch.y_offset if printer.configfile.settings.bltouch.y_offset is defined else Y_OFFSET)|float %}
  {% endif %}
  {% if printer.configfile.config["probe"] is defined %}
    {% set X_OFFSET = (printer.configfile.config.probe.x_offset if printer.configfile.config.probe.x_offset is defined else X_OFFSET)|float %}
    {% set Y_OFFSET = (printer.configfile.config.probe.y_offset if printer.configfile.config.probe.y_offset is defined else Y_OFFSET)|float %}
  {% endif %}

  # bed_mesh boundaries calculations
  # bed_mesh_min and bed_mesh_max
  {% set BED_MESH_MIN_X = BED_MESH_MARGIN if X_OFFSET <= 0.0 else X_OFFSET + BED_MESH_MARGIN |float %}
  {% set BED_MESH_MIN_Y = BED_MESH_MARGIN if Y_OFFSET <= 0.0 else Y_OFFSET + BED_MESH_MARGIN |float %}
  {% set BED_MESH_MAX_X = X_MAX - (X_OFFSET)|abs - BED_MESH_MARGIN if X_OFFSET <= 0.0 else X_MAX - BED_MESH_MARGIN |float %}
  {% set BED_MESH_MAX_Y = Y_MAX - (Y_OFFSET)|abs - BED_MESH_MARGIN if Y_OFFSET <= 0.0 else Y_MAX - BED_MESH_MARGIN |float %}

  # Print values
  {action_respond_info("BED_MESH_MARGIN : %f" % (BED_MESH_MARGIN))}
  {action_respond_info("X_MAX           : %f" % (X_MAX))}
  {action_respond_info("Y_MAX           : %f" % (Y_MAX))}
  {action_respond_info("X_OFFSET        : %f" % (X_OFFSET))}
  {action_respond_info("Y_OFFSET        : %f" % (Y_OFFSET))}
  {action_respond_info("BED_MESH_MIN_X  : %f" % (BED_MESH_MIN_X))}
  {action_respond_info("BED_MESH_MIN_Y  : %f" % (BED_MESH_MIN_Y))}
  {action_respond_info("BED_MESH_MAX_X  : %f" % (BED_MESH_MAX_X))}
  {action_respond_info("BED_MESH_MAX_Y  : %f" % (BED_MESH_MAX_Y))}
  {action_respond_info("--- VALUES TO ADD OR UPDATE TO OUR BED_MESH VALUES ---")}
  {action_respond_info("--- VALORES PARA AGREGAR O ACTUALIZAR EN NUESTRA SECCIÓN BED_MESH ---")}
  {action_respond_info("mesh_max: %s,%s" % (BED_MESH_MAX_X,BED_MESH_MAX_Y))}
  {action_respond_info("mesh_min: %s,%s" % (BED_MESH_MIN_X,BED_MESH_MIN_Y))}

Para lanzar la macro iremos a nuestra UI y podremos lanzarla ajustando el valor BED_MESH_MARGIN que es un margen de seguridad a aplicar alrededor de nuestra área de mallado, por defecto usará 10mm:

Si todo ha ido de forma correcta veremos en la consola información obtenida de nuestra configuración (recuadro naranja), los cálculos de coordenadas (recuadro rojo) y la sugerencia de configuración para nuestro [bed_mesh] en concreto los valores mesh_min y mesh_max (recuadro verde):

Los valores sugeridos los podremos poner en nuestro printer.cfg en la sección [bed_mesh]:

Ejemplo de modificación de valores en base a lo obtenido de la macro:
[bed_mesh]
### mesh_min: 10, 25
mesh_min: 10,32.0 # From CALCULATE_BED_MESH macro
### mesh_max: 390, 405
mesh_max: 381.5,410.0 # From CALCULATE_BED_MESH macro
probe_count: 7, 7
algorithm: bicubic
speed: 100
  • probe_count, es el que indicará el número de sondeos en cada eje... normalmente y dependiendo del estado de nuestra cama 5,5 (25 puntos) suelen ser más que suficientes

  • fade_start fade_end, estos parámetros muy útiles permiten ajustar la desviación inicial de nuestra cama hasta una altura para asegurar una correcta dimensionalidad de nuestras piezas.

    • fade_start, por defecto 1 es la altura de Z a partir de la cual empezaremos la corrección

    • fade_end, por defecto 0 y es la altura de Z que usará para completar las correcciones, normalmente se suele usar 10

  • faulty_regions, es otra función interesante en el caso de que tengamos zonas en las que nuestro sensor falle o reporte medidas incorrectas como camas con imanes integrados o PEI que con su campo magnético pueden afectar a las lecturas de algunos sensores. Esta función puede ayudar a compensar este efecto realizando un sondeo alrededor del punto para obtener valores de compensación en ese punto. La imagen siguiente puede ayudar a entender mejor su funcionamiento, así como el ejemplo de configuración.

[bed_mesh]
speed: 120
horizontal_move_z: 5
mesh_min: 35, 6
mesh_max: 240, 198
probe_count: 5, 3
faulty_region_1_min: 130.0, 0.0
faulty_region_1_max: 145.0, 40.0
faulty_region_2_min: 225.0, 0.0
faulty_region_2_max: 250.0, 25.0
faulty_region_3_min: 165.0, 95.0
faulty_region_3_max: 205.0, 110.0
faulty_region_4_min: 30.0, 170.0
faulty_region_4_max: 45.0, 210.0

Mallado de cama con sensor

Lo más aconsejable por precisión y comodidad es el uso de un sensor de nivelación que nos ayude desde el proceso.

Podemos lanzar el proceso de calibración desde las opciones de vuestra UI Mainsail o Fluidd o por consola lanzando BED_MESH_CALIBRATE, podemos ejecutar BED_MESH_CLEAR para limpiar los valores, una vez efectuado el mallado podemos guardarlo con SAVE_CONFIG.

Un valor añadido de la UI es que tiene un visualizador que nos permite ver el estado de nuestro mallado y por ende nuestra cama.

Mallado de cama adaptativo

En versiones de Klipper desde 26 de Enero de 2024 contamos con una nueva funcionalidad en el mallado de cama... el mallado adaptativo. Ya no necesitaremos macros o extensiones externas a Klipper para disponer de esta funcionalidad!!!

Hemos resaltado la fecha de Klipper a partir que es compatible dado que actualmente muchos fabricantes utilizan host Klipper que estan totalmente desactualizados y sin vistas a que actualicen.

Así que si tienes una Sonic Pad, QIDI, SK1, K1, etc.... mejor que uses alternativas basadas en macros y extensiones externas a Klipper :)

El mallado adaptativo básicamente nos permite realizar el proceso de sondeo de forma dinámica en la zona donde nuestra pieza va a imprimirse, mejorando de esta forma la efectividad del mallado y sus correcciones.

El área de sondeo adaptativo se va a definir dependiendo del área de impresión de nuestras piezas, incluyendo un margen a estas que podremos definir en nuestra configuración. El siguiente paso, una vez definida de forma automática esta área de sondeo, el propio sistema va a escalar el número de puntos a sondear dependiendo de la proporción entre el área normal de sondeo y el área adaptativa calculada para los objetos a imprimir.

Normalmente dada la naturaleza del mallado adaptativo no se suele aprovechar entre impresiones por lo que se genera un nuevo mallado en cada impresión. Es importante que el mallado adaptativo esta especialmente pensado para máquinas que pueden sondear toda la superficie de impresión donde tendremos unos mejores resultados.

Para usar el mallado adaptativo nativo de Klipper va a ser muy sencillo porque básicamente hemos de activar el procesado de objetos de Klipper :

printer.cfg
[exclude_object]

También es necesario el procesado de gcodes en Moonraker:

moonraker.conf
[file_manager]
enable_object_processing: True

Deberemos asegurarnos que nuestro laminador tenga habilitada el etiquetado de objetos:

Por último añadiremos la llamada a la macro BED_MESH_CALIBRATE dentro de nuestra macro START_PRINT (o nombre que usemos en vuestro caso), o en nuestro gcode de inicio si lo tenemos fuera de esta:

printer.cfg (inside your START_PRINT macro)
...
BED_MESH_CALIBRATE ADAPTIVE=1 ADAPTIVE_MARGIN=5
...

Como parámetros en BED_MESH_CALIBRATE para utilizar el mallado adaptativo usaremos:

  • ADAPTATIVE=1 para habilitarlo

  • ADAPTATIVE_MARGIN=5 donde cambiaremos el 5 por el margen que queramos

Tenéis más información y detalle como siempre en la documentación oficial de Klipper.

Mallado de cama manual

También tienes la opción de realizar un mallado de tu cama sin sensor, para ello podremos lanzar BED_MESH_CALIBRATE METHOD=manual Klipper nos irá dando información durante el proceso:

  • Haremos un home de la máquina con G28

  • Iniciaremos la calibración lanzando el comando BED_MESH_CALIBRATE METHOD=manual

  • Mediante comandos iremos bajando lentamente el nozzle hacia la cama usando TESTZ Z=-1 hasta que estemos cerca para en ese momento realizar movimientos más pequeños usando TESTZ Z=-.01 o incluso menos hasta que nuestro nozzle roce con el papel. Podemos alternar el TESTZ con valores positivos/negativos y mayores/menores hasta que tengamos nivelado a nuestro gusto en ese momento lanzaremos un ACCEPT y el asistente irá al siguiente punto de sondeo

  • Al finalizar el sondeo haremos un SAVE_CONFIG que nos guardará la malla "default" o realizaremos un BED_MESH_PROFILE SAVE="manual" y un SAVE_CONFIG para guardar la malla con el nombre "manual"

IMPORTANTE!!!

Para evitar errores de movimientos fuera de rango en el proceso de z-offset u otras nivelaciones hemos de ajustar el position_min de nuestro stepper_z a un valor adecuado y con cierto margen para que nos permita esos movimientos.

[stepper_z]
...
position_min: -5
...

Para cargar el perfil creado manual deberéis aseguraros que vuestra macro o gcode de inicio de vuestro laminador lance la macro BED_MESH_PROFILE LOAD=manual .

A continuación os facilitamos una macro para poder lanzar el proceso de forma cómoda:

[gcode_macro G29_MANUAL]
description: Realiza la malla de forma manual
gcode:
        BED_MESH_CLEAR
        G28 XY
        G28 Z
        BED_MESH_CALIBRATE METHOD=manual
        BED_MESH_PROFILE SAVE="manual"
        SAVE_CONFIG

Última actualización