Malla nivelación de cama

Configuración completa de la malla de nivelación de cama en Klipper: bed_mesh, mallado adaptativo nativo, perfiles y compensación física.

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:

Bed Mesh - Klipper documentationwww.klipper3d.org

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:

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

Ejemplo visual de las correcciones fade

Precauciones con el uso de fade_start y fade_end!!! Todo y que estas configuraciones pueden permitir mejorar la dimensionalidad correcta en nuestras impresiones configuraciones agresivas pueden provocar artefactos como la delaminación (fallos de adhesión entre capas), en especial cuando la distancia entre el inicio y final de las correcciones es muy cercana y no permite realizar unas transiciones entre capas adecuadas para adaptar/compensar las desviaciones o ajustes necesarios.

• 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

Definición [bed_mesh]

 rectangular bed, probe_count = 3, 3:
             x---x---x (max_point)
             |
             x---x---x
                     |
 (min_point) x---x---x

 round bed, round_probe_count = 5, bed_radius = r:
                 x (0, r) end
               /
             x---x---x
                       \
 (-r, 0) x---x---x---x---x (r, 0)
           \
             x---x---x
                   /
                 x  (0, -r) start

[bed_mesh]
#speed: 50
#   The speed (in mm/s) of non-probing moves during the calibration.
#   The default is 50.
#horizontal_move_z: 5
#   The height (in mm) that the head should be commanded to move to
#   just prior to starting a probe operation. The default is 5.
#mesh_radius:
#   Defines the radius of the mesh to probe for round beds. Note that
#   the radius is relative to the coordinate specified by the
#   mesh_origin option. This parameter must be provided for round beds
#   and omitted for rectangular beds.
#mesh_origin:
#   Defines the center X, Y coordinate of the mesh for round beds. This
#   coordinate is relative to the probe's location. It may be useful
#   to adjust the mesh_origin in an effort to maximize the size of the
#   mesh radius. Default is 0, 0. This parameter must be omitted for
#   rectangular beds.
#mesh_min:
#   Defines the minimum X, Y coordinate of the mesh for rectangular
#   beds. This coordinate is relative to the probe's location. This
#   will be the first point probed, nearest to the origin. This
#   parameter must be provided for rectangular beds.
#mesh_max:
#   Defines the maximum X, Y coordinate of the mesh for rectangular
#   beds. Adheres to the same principle as mesh_min, however this will
#   be the furthest point probed from the bed's origin. This parameter
#   must be provided for rectangular beds.
#probe_count: 3, 3
#   For rectangular beds, this is a comma separate pair of integer
#   values X, Y defining the number of points to probe along each
#   axis. A single value is also valid, in which case that value will
#   be applied to both axes. Default is 3, 3.
#round_probe_count: 5
#   For round beds, this integer value defines the maximum number of
#   points to probe along each axis. This value must be an odd number.
#   Default is 5.
#fade_start: 1.0
#   The gcode z position in which to start phasing out z-adjustment
#   when fade is enabled. Default is 1.0.
#fade_end: 0.0
#   The gcode z position in which phasing out completes. When set to a
#   value below fade_start, fade is disabled. It should be noted that
#   fade may add unwanted scaling along the z-axis of a print. If a
#   user wishes to enable fade, a value of 10.0 is recommended.
#   Default is 0.0, which disables fade.
#fade_target:
#   The z position in which fade should converge. When this value is
#   set to a non-zero value it must be within the range of z-values in
#   the mesh. Users that wish to converge to the z homing position
#   should set this to 0. Default is the average z value of the mesh.
#split_delta_z: .025
#   The amount of Z difference (in mm) along a move that will trigger
#   a split. Default is .025.
#move_check_distance: 5.0
#   The distance (in mm) along a move to check for split_delta_z.
#   This is also the minimum length that a move can be split. Default
#   is 5.0.
#mesh_pps: 2, 2
#   A comma separated pair of integers X, Y defining the number of
#   points per segment to interpolate in the mesh along each axis. A
#   "segment" can be defined as the space between each probed point.
#   The user may enter a single value which will be applied to both
#   axes. Default is 2, 2.
#algorithm: lagrange
#   The interpolation algorithm to use. May be either "lagrange" or
#   "bicubic". This option will not affect 3x3 grids, which are forced
#   to use lagrange sampling. Default is lagrange.
#bicubic_tension: .2
#   When using the bicubic algorithm the tension parameter above may
#   be applied to change the amount of slope interpolated. Larger
#   numbers will increase the amount of slope, which results in more
#   curvature in the mesh. Default is .2.
#zero_reference_position:
#   An optional X,Y coordinate that specifies the location on the bed
#   where Z = 0.  When this option is specified the mesh will be offset
#   so that zero Z adjustment occurs at this location.  The default is
#   no zero reference.
#relative_reference_index:
#   **DEPRECATED, use the "zero_reference_position" option**
#   The legacy option superceded by the "zero reference position".
#   Rather than a coordinate this option takes an integer "index" that
#   refers to the location of one of the generated points. It is recommended
#   to use the "zero_reference_position" instead of this option for new
#   configurations. The default is no relative reference index.
#faulty_region_1_min:
#faulty_region_1_max:
#   Optional points that define a faulty region.  See docs/Bed_Mesh.md
#   for details on faulty regions.  Up to 99 faulty regions may be added.
#   By default no faulty regions are set.

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.

IMPORTANTE!!! Habilitar/Cargar un perfil de malla de nivelación:

Antiguamente Klipper cargaba por defecto la malla default al iniciarse, actualmente no es así. Si queréis que vuestra malla sea efectiva durante vuestras impresiones tenemos tres opciones.

Cargar la malla de forma manual, es algo engorroso ya que podemos olvidarnos.

Cargar la malla en nuestra rutina de inicio de impresión en la macro que usemos, START_PRINT o el nombre que usemos, o en el gcode de inicio de nuestro laminador aunque os aconsejamos siempre usar la macro ya que es la forma más efectiva... tan solo tendremos que añadir BED_MESH_PROFILE LOAD=default antes de comenzar la impresión.

También podemos añadir la siguiente macro para que haga el proceso de igual forma que se hacía antes del cambio en Klipper.

[delayed_gcode bed_mesh_init]
initial_duration: .01
gcode: 
  BED_MESH_PROFILE LOAD=default

En este caso adaptaremos el nombre de malla si usamos un nombre diferente, en el caso que usemos diferentes mallas deberemos de tenerlo en cuenta para cargar por el método que sea la correcta antes de iniciar la impresión.

Mallado de cama adaptativo

Desde enero de 2024, Klipper incluye mallado adaptativo de forma nativa. Ya no necesitas macros externas como KAMP para esta funcionalidad.

Esta función requiere Klipper actualizado (desde enero 2024). Si tienes una máquina con Klipper personalizado del fabricante (Sonic Pad, QIDI, Creality K1, etc.) que no admite actualizaciones, usa la alternativa con KAMP o el script de mallado por área del 3Dwork Klipper Bundle.

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:

Bambu Studio/OrcaSlicer

PrusaSlicer

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:

• ADAPTIVE=1 para habilitarlo

• ADAPTIVE_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

zero_reference_position — referencia Z de la malla

zero_reference_position define el punto de la cama donde Z = 0. La malla se ajusta para que la compensación sea cero en ese punto, lo que garantiza que el Z-offset siga siendo válido en toda la cama.

[bed_mesh]
...
zero_reference_position: 125, 125   # Centro de la cama (ajusta a tu máquina)

Si haces home en el centro de la cama o usas un sensor tipo Beacon/Eddy que calibra el Z-offset en un punto fijo, configura zero_reference_position en ese mismo punto. Así evitas que la compensación de malla desplace la Z-offset en la zona de home.

La opción anterior relative_reference_index está deprecada — si la tienes en tu cfg, sustitúyela por zero_reference_position.

---

Resolución de problemas

Síntoma	Causa probable	Solución
El mallado sondea toda la cama aunque uses ADAPTIVE=1	[exclude_object] no está activo o el laminador no etiqueta objetos	Activa [exclude_object] en printer.cfg y enable_object_processing: True en moonraker.conf
Primera capa varía mucho de impresión a impresión	La malla no se carga en cada impresión	Añade BED_MESH_CALIBRATE ADAPTIVE=1 en PRINT_START en lugar de cargar un perfil guardado
El mallado adaptativo usa menos puntos de los esperados	Objeto muy pequeño → la escala reduce el probe_count	Normal — el sistema escala proporcionalmente. Aumenta probe_count base si necesitas más resolución
Error "move out of range" al iniciar el mallado	mesh_min/mesh_max fuera de los límites de la impresora con el offset del sensor	Usa la macro CALCULATE_BED_MESH para calcular los valores correctos
La malla empeora entre capas (delaminación)	fade_end demasiado bajo o fade_start y fade_end muy próximos	Usa fade_start: 1 y fade_end: 10 como mínimo
Puntos erróneos en zonas con imanes del PEI	Interferencia magnética con el sensor inductivo	Configura faulty_regions para esas zonas

Compensación física de cama

En ocasiones nos podemos encontrar con que nuestra plataforma de impresión tenga unas desviaciones bastante grandes, siempre entendiendo que nuestras mediciones fueron fiables, y el sistema de compensación de malla del sistema puede tener problemas para compensar estas.

Un método tradicional ha sido la de usar cinta de aluminio cortada en secciones para intentar compensar estas desviaciones... y vuelvo a recalcar... en aquellos casos en los que tengamos unas medidas fiables de nuestro sensor y no tengamos otra forma alternativa de compensar estas desviaciones

En las anteriores imágenes de ejemplo podemos ver la plataforma de impresión de una impresora y como utilizando estas cintas por secciones podemos compensar estas desviaciones tal como podeis ver en las siguientes imágenes de como afectó la corrección al mallado:

Siempre que el número de capas de cinta de aluminio no sean excesivas este método no suele afectar a la eficiencia en la temperatura de la cama caliente y en ocasiones incluso puede mejorarla a distribuir un poco mejor esta.

Para poder realizar estas compensaciones hemos creado una herramienta que simplemente exportando nuestro printer.cfg va a obtener la configuración de vuestra impresora y mallado actual y con el nombre default, que ha de ser fiable, y introduciendo el grosor de la cinta de aluminio que vayáis a utilizar (a menor grosor mejor ajuste fino) os va a proporcionar el número de cuadrantes a cubrir con x número de capas de cinta de aluminio.

Una vez cargado vuestro printer.cfg la herramienta os mostrará los datos obtenidos de esta como el tamaño de impresión XY, la matriz del mallado utilizado, y los rangos de desviaciones calculados:

Por otro lado os va a sugerir el tamaño de los cuadrantes de cinta de aluminio y mostrar un mapa de cuantos colocar en cada cuadrante:

También nos va a mostrar una estimación de como deberia quedar el mallado una vez aplicada la cinta de aluminio, es solo a modo de referencia:

Por último también disponemos de una gráfica para visualizar el estado de nuestra malla cargada así como los puntos que se tomarán de referencia (los de mayor altura) para realizar los cálculos y otra pestaña para mostrar los datos capturados de vuestra configuración:

Aunque lo ideal es que vuestra plataforma de impresión sea lo más plana posible o el sistema de nivelación compense estas desviaciones este método casero ayuda a minimizar estas desviaciones y a mejorar significativamente los resultados. Espero que os sea de ayuda como nos ha sido a nosotros en muchas ocasiones.