Input Shaper

Guía completa de calibración de Input Shaper en Klipper: compensación de resonancias y ringing con acelerómetro ADXL345/LIS2DW, interpretación de gráficas, Shake&Tune y método manual.

Una de las grandes funcionalidades de Klipper —y que hoy también está disponible en Marlin (desde la versión 2.1) y en Duet— es el soporte a Input Shaping, una técnica que permite reducir las vibraciones/ondas (ringing, echoing, ghosting, rippling son otros nombres de ese tipo de artefactos).

Este tipo de artefactos están producidos por vibraciones mecánicas originadas normalmente por los movimientos bruscos en los cambios de direcciones. Algo ocasionado normalmente por... un chasis no suficientemente rigido, correas muy o poco tensas, problemas de alineación en partes del chasis o cinemática, movimientos de masas grandes en los ejes de movimiento, etc... por lo que es aconsejable que antes de comenzar en estos ajustes nos aseguremos que hemos intentado solventar lo máximo posible los fallos más comunes comentados.

Input Shaping nos permite minimizar esas vibraciones, normalmente a altas velocidades, optimizando los movimientos de los motores para producir las mínimas vibraciones. El objetivo es realizar unas aceleraciones suaves y fluídas que emitan menos vibraciones para conseguir una mayor calidad en nuestras impresiones.

Dmitry Butyugin fué el primero en implementar Input Shaping en Klipper en Agosto 2020. Con la ayuda de un acelerómetro ADXL34X encontró una forma de medir las frecuencias de resonancia de la impresora y determinar los parámetros para minimizarlas tal como os comentamos en el punto anterior.

Dado que es un proceso muy extenso os vamos a explicar las dos formas de poder ajustar Input Shaping facilitando links a la documentación oficial, recordaros que en nuestro caso usamos un sensor para medir las resonancias de nuestra máquina ya que suele ser la forma más precisa y automática para obtener los mejores resultados.

¿Qué necesitas para calibrar Input Shaper?

Proceso en 5 pasos:

Conectar y configurar el acelerómetro → sección Acelerómetros
Verificar que responde (ACCELEROMETER_QUERY)
Lanzar el test (TEST_RESONANCES o SHAPER_CALIBRATE en modo automático)
Interpretar las gráficas y copiar los valores a [input_shaper] en printer.cfg
Ajustar max_accel en la sección [printer]

Requisito

Detalles

Acelerómetro

ADXL345, LIS2DW o el integrado en tu toolhead board (EBB, SB2209...)

Host Klipper

Raspberry Pi, CB1, Orange Pi u otro host compatible

Software

numpy + matplotlib (ya incluidos en MainsailOS / FluiddOS / RatOS)

Tiempo estimado

20-30 minutos la primera vez

Acelerómetros

Como os aconsejamos en el punto anterior es aconsejable del uso de un acelerómetro que de una forma más automatizada y fiable nos va a proporcionar datos más fiables.

Aunque no esté relacionado directamente con Klipper creemos muy interesante hacer una muy breve introducción a que es un acelerómetro y como funciona. Un acelerómetro básicamente es un dispositivo que nos va a permitir medir y analizar la aceleración lineal/angular convirtiendo la energía generada por las vibraciones en una señal eléctrica proporcional a la aceleración momentánea del objeto.

Normalmente se suelen usar acelerómetros MEMS (Micro Electro Mechanical System) dado que son precisos, fiables y baratos. Básicamente, tal como podéis ver las siguientes imágenes, es un peso montado en unos resortes mientras el otro es fijo normalmente en forma de peine:

Cuando se produce una aceleración la parte en el resorte se desplaza y gracias a ese movimiento podemos medir la capacidad eléctrica que nos va a permitir obtener un valor:

Por último y a modo de ejemplo tenéis una imagen de como sería internamente un acelerómetro de 3 ejes donde podréis ver lo anterior en el mundo real:

Acelerómetros compatibles con Klipper

Klipper soporta de forma nativa los siguientes acelerómetros para medición de resonancias:

Sensor

Bus

Notas

ADXL345 / ADXL343

SPI

El histórico, sigue siendo el más usado. Económico y muy probado.

MPU-6050 / MPU-9250

I2C

Alternativa I2C muy habitual en toolheads que no exponen SPI.

LIS2DW

SPI o I2C

Integrado en muchas toolhead boards modernas (EBB, SB2209).

LIS3DH

SPI o I2C

Añadido recientemente a Klipper. Misma configuración que LIS2DW.

ICM-20948

I2C

Añadido recientemente a Klipper. Compatible con la familia MPU.

LIS3DH se incorporó al árbol oficial de Klipper en 2024 y ICM-20948 poco después (con una corrección posterior del rango de escala 2g→8g). Antes había que parchear o usar forks; hoy basta con la configuración nativa.

Documentación oficial: Measuring Resonances
Sección Acelerómetros adicionales (LIS3DH, ICM-20948) más abajo con los snippets de configuración.

Acelerómetro, puesta en marcha

En las siguientes pestañas podéis encontrar las diferentes opciones para disponer de un acelerómetro para nuestra máquina:

IMPORTANTE!!! Sobre acelerómetros ADXL34X

Existen diferentes tipos de placas ADXL345, o ADXL343 que son alternativas. Dependiendo del tipo de placa y sus componentes tendremos que tener en consideración cuando la conectemos a nuestro controlador Pi.

Regulador de Voltaje, estas placas pueden alimentarse tanto a 3.3v como 5v. El chip ADXL34X trabaja a 3.3v, pero en el caso de tener un regulador de voltaje permitirá que solo esos 3.3v lleguen al chip, independientemente de la alimentación que usemos Placas sin regulador de voltaje NO se deben de alimentar a 5v ya que puede/va a dañar nuestra placa.
Level Shifter, un level shifter permite traducir señales entre 3.3v y 5v o viceversa. Como ya hemos comentado, ADXL34XX funciona a 3.3v. El level shifter permite que un ADXL34X alimentado a 5v permita que sus salidas funcionen a 5v también. Es importante recordar que nuestras Raspberry y la mayoría de MCUs están diseñadas para funcionar 3.3v. Una placa ADXLxxx no se debería alimentar a 5v si tiene una circuitería level shifter.

<figure><img src="../../.gitbook/assets/image (1194).png" alt=""><figcaption><p>Ejemplo ADXL34X con regulador de voltaje y level shifter</p></figcaption></figure>

<figure><img src="../../.gitbook/assets/image (1800).png" alt=""><figcaption><p>Ejemplo ADXL34X solamente regulador de voltaje</p></figcaption></figure>

Si no os queréis complicar montando vosotros mismos las soldaduras y cableado necesarios, aunque es muy divertido hacerlo!!!, podéis optar por unos comerciales que ya vienen montados:

https://s.click.aliexpress.com/e/_DcynuSh

Fysetc Pico firmware Klipper

El siguiente paso a realizar los siguientes pasos para preparar y aplicar el firmware Klipper a nuestra Fysetc Pico accediento a nuestro host Klipper por SSH (PuTTy/Terminus):

Lanzaremos el comando para preparar nuestro firmware Klipper para nuestra Fysetc Pico:

cd ~/klipper
make menuconfig

En la configuración del firmware seleccionaremos:

[ ] Enable extra low-level configuration options
Micro-controller Architecture (Raspberry Pi RP2040)  --->
Communication interface (USB)  --->

Presionaremos Q y luego Y para guardar los cambios
Reiniciaremos el servicio Klipper:

sudo service klipper stop

Haremos una limpieza de make para asegurarnos que todo está limpio

sudo make clean

Generaremos el firmware:

make

Conectaremos nuestra Fysetc Pico por USB a nuestra Raspberry Pi dejando presionado el botón de boot en la Pi Pico para que monte la unidad de boot y ejecutaremos lo siguiente:

Asumimos que la Fysetc Pico es el único dispositivo USB conectado a la Raspberry Pi y que este se ha montado sobre /dev/sda

## montamos la unidad de boot de nuestra pi pico
sudo mount /dev/sda1 /mnt
## copiamos el firmware klipper generado previamente a nuestra pi pico
sudo cp out/klipper.uf2 /mnt
## desmontamos nuestra pi pico
sudo umount /mnt

ya podemos reconectar Fysetc pi pico por USB y buscaremos el serial id el cual anotaremos ya que deberemos de usarlo en siguientes pasos

ls /dev/serial/by-id/

una vez finalizado el proceso arrancaremos el servicio Klipper de nuevo:

sudo service klipper start

Configuración Klipper

dentro de nuestra interfaz de Klipper y para que el uso sea modular lo ideal es crear un nuevo fichero de configuración PIS.cfg para incluir la configuración de nuestro acelerómetro Fysetc:

Not found

PIS.cfg

[mcu PIS]
# Obtain definition by "ls -l /dev/serial/by-id/" then unplug to verify
serial: /dev/serial/by-id/xxxx

[adxl345]
cs_pin: PIS:gpio13
#spi_bus: spi1a
spi_software_sclk_pin: PIS:gpio10
spi_software_mosi_pin: PIS:gpio11
spi_software_miso_pin: PIS:gpio12
axes_map: x,-z,y

[resonance_tester]
accel_chip: adxl345
probe_points:
    100,100,20 # an example

Sobre el PIS.cfg de Fysetc vamos a realizar algunos ajustes importantes:

En la sección [mcu PIS] ajustaremos el valor de serial para que se ajuste al que obtivimos previamente, en nuestro ejemplo:

PIS.cfg

[mcu PIS]
# Obtain definition by "ls -l /dev/serial/by-id/" then unplug to verify
serial: /dev/serial/by-id/usb-Klipper_rp2040_E66118F5D7537136-if00

También, por compatibilidad con algunos sistemas como RatOS, ajustaremos la sección [adxl345] para añadir un identificador en nuestro caso usaremos fysetc para distinguirlo de otros posibles que podamos tener:

PIS.cfg

[adxl345 fysetc]
cs_pin: PIS:gpio13
#spi_bus: spi1a
spi_software_sclk_pin: PIS:gpio10
spi_software_mosi_pin: PIS:gpio11
spi_software_miso_pin: PIS:gpio12
axes_map: x,-z,y

Ajustaremos, axes_map que indicara la dirección de movimientos de la máquina. Para más información sobre axes_map podéis revisar la documentación oficial de Klipper aquí. Básicamente es para indicar con respecto a la posicion del acelerómetro y el movimiento de la máquina... por ejemplo si colocamos el sensor con orientación Y para el eje de movimiento X usaremos y, x, z... y si lo tenemos invertido usaremos el simbolo - delante
Por último y en la sección [resonance_tester] ajustaremos el accel_chip para indicarle el nuestro con el ID que establecimos en el paso anterior, y segundo ajustar las coordenadas probe_points a unas adecuadas a nuestra máquina... normalmente en el centro de nuestra cama de impresión:

PIS.cfg

[resonance_tester]
accel_chip: adxl345 fysetc
probe_points:
    210,210,20 # an example

Si queremos un extra :) podemos añadir otra sección, al final de nuestro PIS.cfg, para mostrar los datos de nuestro Fysetc Pico en la sección MACHINE:

[temperature_sensor PIS]
sensor_type = temperature_mcu
sensor_mcu: PIS

Con el fichero de configuración de nuestro Fysetc Pico ajustado tan solo tendremos que indicar a nuestro printer.cfg que lo cargue.

incluiremos nuestro nuevo fichero de adxl345_pico.cfg en nuestro printer.cfg habilitándolo cuando necesitemos realizar el proceso de input shaper:
```
# Descomentar la siguiente linea para usar ADXL345 conectada a la Pi Pico
[include PIS.cfg] 
```

En caso de usar una distribución RatOS y usar definiciones de sus configuraciones de electrónica mediante includes o directamente tener una máquina Ratrig has de tener en cuentra:

NO has de habilitar ningún include de acelerómetro
el include del fichero PIS.cfg has de realizarlo en la zona USER OVERRIDES si usamos un template de configuración de RatOS

Reiniciaremos Klipper usando el comando RESTART

La CB1 de Bigtreetech es una gran alternativa a las Raspberry Pi que cuentan con la ventaja de su precio, grandes prestaciones y poder usarse en la serie Manta de Bigtreetech.

La CB1, al estar conectada a la electrónica Manta o alguno de sus adaptadores, dispone de un GPIO el cual... aunque limitado con respecto a la Raspberry Pi... podremos usar para conectar nuestro acelerómetro.

Para poder cablear nuestro acelerómetro seguiremos el siguiente diagrama:

ADXL345

CB1

GND

Ground

VCC

3v3

GPIO22

SDO

GPIO9

SDA

GPIO10

SCL

GPIO11

El siguiente paso será habilitar SPI en nuestra CB1 en el directorio /boot/ en su BoardEnv.txt... podéis acceder a el por SSH o WinSCP.

Descomentaremos o añadiremos las siguientes líneas:

/boot/BoardEnv.txt

# uncomment the following overlays and parameters to release 'spidev1.1' to user space
# NOTE: 'spidev1.1' cannot be used together with TFT35_SPI and MCP2515
overlays=spi-spidev
param_spidev_spi_bus=1
param_spidev_spi_cs=1
param_spidev_max_freq=1000000

Guardamos los cambios y reiniciamos nuestra CB1. Ajustaremos nuestro printer.cfg:

printer.cfg

[mcu cb1]
serial: /tmp/klipper_host_mcu

[adxl345]
cs_pin: cb1:gpiochip0/gpio74
spi_bus: spidev1.1
axes_map: x,-z,y

[resonance_tester]
accel_chip: adxl345
probe_points:
 100, 100, 20

Otra opción muy interesante es la de instalar nuestro sensor directamene a nuestra electrónica de esta forma no necesitamos componentes externos.

Es importante aclarar que NO todas las electrónicas pueden usarse de esta manera, en concreto aquellas que no tengan pines SPI expuestos para su uso.

En la siguiente imagen puedes ver como conectar el sensor a una Octopus en su puerto SPI:

Añadiremos la configuración de sensor en nuestro printer.cfg:

[adxl345]
spi_bus: spi3
cs_pin: PA15
axes_map: x,-z,y

[resonance_tester]
accel_chip: adxl345
probe_points:
    90,90,20 # coordenadas del test idealmente el centro de tu cama

En axes_map que indicara la dirección de movimientos de la máquina. Para más información sobre axes_map podéis revisar la documentación oficial de Klipper aquí. Básicamente es para indicar con respecto a la posicion del acelerómetro y el movimiento de la máquina... por ejemplo si colocamos el sensor con orientación Y para el eje de movimiento X usaremos y, x, z... y si lo tenemos invertido usaremos el simbolo - delante

Usando Pi Pico como interfaz/MCU secundaria para conectar nuestro acelerómetro nos permite el tener una solución más cómoda y común para todas nuestras impresoras además que nos permite normalmente reducir enormemente la longitud del cableado entre el sensor y el host/MCU de control reduciendo problemas relacionados con interferencias en los cables de forma considerable.

La Pi Pico es una MCU de Raspberry de bajo coste y fácil de encontrar. Nuestro BOM de componentes.

Componente

Unidades

Tiendas

Raspberry Pi Pico

1 (es aconsejable 2 por tener una de backup)

- https://amzn.to/3r86W1r

Adafruit ADXL345

1 (es aconsejable 2 por tener de backup)

- https://amzn.to/3Kh8WMi

Cables USB, conectores DuPont, cable CAT6, soldador

La conexión entre nuestra Pi Pico y nuestro acelerómetro es relativamente sencilla y podéis usar el siguiente esquema como referencia:

Rol

RPI Pico (pin)

RPI Pico (nombre pin)

VCC (3v3)

3v3 VCC

GND

Ground

SPIO CSn

SDO

SPIO Rx

SDA

SPIO Tx

SCL

SPIO SCK

Pi Pico firmware Klipper

El siguiente paso a realizar los siguientes pasos para preparar y aplicar el firmware Klipper a nuestra Pi Pico accediento a nuestro host Klipper por SSH (PuTTy/Terminus):

Lanzaremos el comando para preparar nuestro firmware Klipper para nuestra Pi Pico:

cd ~/klipper
make menuconfig

En la configuración del firmware seleccionaremos:

[ ] Enable extra low-level configuration options
Micro-controller Architecture (Raspberry Pi RP2040)  --->
Communication interface (USB)  --->

Presionaremos Q y luego Y para guardar los cambios
Reiniciaremos el servicio Klipper:

sudo service klipper stop

Haremos una limpieza de make para asegurarnos que todo está limpio

sudo make clean

Generaremos el firmware:

make

Conectaremos nuestra Pi Pico por USB a nuestra Raspberry Pi dejando presionado el botón de boot en la Pi Pico para que monte la unidad de boot y ejecutaremos lo siguiente:

## montamos la unidad de boot de nuestra pi pico
sudo mount /dev/sda1 /mnt
## copiamos el firmware klipper generado previamente a nuestra pi pico
sudo cp out/klipper.uf2 /mnt
## desmontamos nuestra pi pico
sudo umount /mnt

Asumimos que la Pi Pico es el único dispositivo USB conectado a la Raspberry Pi y que este se ha montado sobre /dev/sda

ya podemos reconectar la pi pico por USB y buscaremos el serial id el cual anotaremos ya que deberemos de usarlo en siguientes pasos

ls /dev/serial/by-id/

una vez finalizado el proceso arrancaremos el servicio Klipper de nuevo:

sudo service klipper start

Configuración Klipper

dentro de nuestra interfaz de Klipper y para que el uso sea modular lo ideal es crear un nuevo fichero de configuración adxl345_pico.cfg para incluir la configuración de nuestro acelerómetro:

adxl345_pico.cfg

## Configuración ADXL345 usando Pi Pico
[mcu pico]
serial: /dev/serial/by-id/usb-Klipper_rp2040_E660REDACTED-if00

[adxl345]
cs_pin: pico:gpio1
spi_bus: spi0a
axes_map: x,z,y

[resonance_tester]
accel_chip: adxl345
probe_points:
    90,90,20 # coordenadas del test idealmente el centro de tu cama

Raspberry Pi Pico, buses SPI disponibles.

Es posible conectar múltiples dispositivos SPI a nuestra Pi Pico en paralelo. En la siguiente tabla podéis encontrar los pines y el ID de SPI en cada caso.

Para nuestro ejemplo usamos el bus SPI spi0a.

incluiremos nuestro nuevo fichero de adxl345_pico.cfg en nuestro printer.cfg habilitándolo cuando necesitemos realizar el proceso de input shaper:
```
# Descomentar la siguiente linea para usar ADXL345 conectada a la Pi Pico
[include adxl345_pico.cfg] 
```
Reiniciaremos Klipper usando el comando RESTART

La opción más común suele ser conectar directamente nuestro acelerómetro directamente a nuestro host Klipper, en el caso de ser una Raspberry Pi o similar.

Pese a que es la opción más común tenemos que recordar que el uso de un acelerómetro directamente a nuestra Pi puede dar algunos quebraderos de cabeza dado que la longitud, calidad y construcción del cableado puede influir en la comunicación entre el sensor y nuestra Pi.

Aunque Klipper es compatible con diferentes tipos de acelerómetros vamos a usar el más común que es el ADXL345 en cualquier caso en la documentación de Klipper podéis encontrar otras opciones.

Componente

Unidades

Tiendas

Adafruit ADXL345

1 (es aconsejable 2 por tener de backup)

- https://amzn.to/3Kh8WMi

Cables USB, conectores DuPont, cable CAT6, soldador

El primer paso será montar el cableado para nuestro sensor y nuestra Pi. Tal como os adelantábamos es importante que usemos conectores dupont que proporcionen una buena conexión y un cableado adecuado, normalmente cable de red CAT6 suele dar un buen resultado gracias al trenzado y apantallado.

Una vez tenemos las conexiones nos aseguraremos que tenemos activado la comunicación SPI en nuestra Pi. Para ello conectaremos por SSH (PuTTy o Terminus) a nuestra Pi y lanzaremos la utilidad raspi-config:

sudo raspi-config

Dentro del menú de configuración que aparece seleccionaremos

#3 >> Interface Options >> P4 SPI >> Yes >> OK >> Finish

La utilidad raspi-config puede cambiar el orden de los menús anteriores en futuras actualizaciones... aplica el sentido común si no ves exactamente este orden de menús 👍

Configuración Pi como segunda MCU

Para poder acceder a determinados recursos de nuestra Pi, como es el caso del acelerómetro, deberemos realizar el proceso explicado en esta guía para poder usar nuestra Pi como segunda MCU.

Configuración Klipper

dentro de nuestra interfaz de Klipper y para que el uso sea modular lo ideal es crear un nuevo fichero de configuración adxl345_rpi.cfg para incluir la configuración de nuestro acelerómetro:

adxl345_rpi.cfg

[mcu rpi]
serial: /tmp/klipper_host_mcu

[adxl345]
cs_pin: rpi:None
axes_map: x,-z,y

[resonance_tester]
accel_chip: adxl345
probe_points:
    100, 100, 20  # an example

En axes_map que indicara la dirección de movimientos de la máquina. Para más información sobre axes_map podéis revisar la documentación oficial de Klipper aquí. Básicamente es para indicar con respecto a la posicion del acelerómetro y el movimiento de la máquina... por ejemplo si colocamos el sensor con orientación Y para el eje de movimiento X usaremos y, x, z... y si lo tenemos invertido usaremos el simbolo - delante
incluiremos nuestro nuevo fichero de adxl345_rpi.cfg en nuestro printer.cfg habilitándolo cuando necesitemos realizar el proceso de input shaper:

# Descomentar la siguiente linea para usar ADXL345 conectada a la Pi Pico
[include adxl345_rpi.cfg]

Reiniciaremos Klipper usando el comando RESTART

Otra opción es la de usar un Arduino que seguro que tenemos por casa para nuestros proyectos maker para gestionar nuestro acelerómetro. Es importante recordar que es aconsejable usar un Arduino con una MCU relativamente potente dado que el flujo de datos entre el acelerómetro y nuestro Arduino es bastante intensivo.

Conectaremos ambos componentes siguiendo el siguiente esquema de conexiones:

Arduino

ADXL345

GND

3v3

VCC

SDO

SDA

SCL

Arduino firmware Klipper

Conectamos el cable USB a nuestra Raspberry Pi
Buscaremos el id del serial para detectar nuestro Android mediante el siguiente comando:

ls /dev/serial/by-id/

Iremos a la carpeta Klipper:

cd ~/klipper

Lanzaremos el comando para preparar nuestro firmware Klipper para Arduino:

make menuconfig

En la configuración del firmware seleccionaremos:
- Atmega AVR como arquitectura del micro-controlador
- En el modelo del procesador seleccionaremos el nuestro, para el ejemplo atmega328p
Presionaremos Q y luego Y para guardar los cambios
Reiniciaremos el servicio Klipper:

sudo service klipper stop

Subiremos el firmware Klipper a nuestro Arduino con el siguiente comando, es importante usar el id del serial detectado en pasos anteriores:

make flash FLASH_DEVICE=/dev/serial/by-id/[id-serial-arduino]

una vez finalizado el proceso arrancaremos el servicio Klipper de nuevo:

sudo service klipper start

Configuración en Klipper

En nuestro printer.cfg añadiremos el siguiente include al incio:

[include arduino.cfg]

Crearemos un nuevo archivo con el nombre arduino.cfg a la misma altura que nuestro printer.cfg, deberemos ajustar el serial por el que detectamos en pasos anteriores además de las coordenadas para los test:

[mcu ardu]

serial: /dev/serial/by-id/usb-Arduino__www.arduino.cc__0043_85830303339351409150-if00

[adxl345]
cs_pin: ardu:PB2
axes_map: x,-z,y

[resonance_tester]
accel_chip: adxl345
probe_points:
90,90,50 # como ejemplo

En axes_map que indicara la dirección de movimientos de la máquina. Para más información sobre axes_map podéis revisar la documentación oficial de Klipper aquí. Básicamente es para indicar con respecto a la posicion del acelerómetro y el movimiento de la máquina... por ejemplo si colocamos el sensor con orientación Y para el eje de movimiento X usaremos y, x, z... y si lo tenemos invertido usaremos el simbolo - delante
Reiniciaremos Klipper:

sudo service klipper restart

Los acelerómetros LIS2DW son soportados recientemente (Agosto 2023, por lo que si vuestra instalación es más antigua es hora de actualizar!!!) por parte de Klipper. Al igual que los ADXL345 utilizan el interfaz SPI para cominicarse con el host/MCU lo que permiten unas velocidades de hasta 400kbit/s.

En el caso del BTT S2DW es una solución que funciona con su propia MCU, una RPI2040 con doble ARM Cortex-M0+ @ 133MHz que nos asegura que no vamos a tener problemas de proceso, y la conectaremos por USB lo que va a eliminar problemas de cableado y simplificar su uso aunue tambien disponemos del interfaz SPI para poder conectar con cables.

Por otro lado estos acelerómetros prometen casi el doble de precisión, menos nivel de ruido y menos afectación por la temperatura comparados con un ADXL345:

Pasos para preparar y aplicar el firmware Klipper a nuestra BTT S2DW accediento a nuestro host Klipper por SSH (PuTTy/Terminus):

Lanzaremos el comando para preparar nuestro firmware Klipper para nuestra BTT S2DW:

cd ~/klipper
make menuconfig

En la configuración del firmware seleccionaremos:

[*] Enable extra low-level configuration options
Micro-controller Architecture (Raspberry Pi RP2040)  --->
Bootloader offset (No bootloader) --->
Flash chip (W25Q080 with CLKDIV 2) --->
Communication interface (USB)  --->

Presionaremos Q y luego Y para guardar los cambios
Reiniciaremos el servicio Klipper:

sudo service klipper stop

Haremos una limpieza de make para asegurarnos que todo está limpio

sudo make clean

Generaremos el firmware:

make

Conectaremos nuestra BTT S2DW por USB a nuestro host dejando presionado el botón de BOOT para entrar en modo DFU y ejecutaremos lo siguiente:

Usaremos el comando lsusb para listar los dispositivos conectados a nuestro host y localizar el de nuestra BTT S2DW, en nuestro caso 2e8a:0003:

A continuación lanzaremos el comando para aplicar el firmware, recuerda ajustar el FLASH_DEVICE al obtenido en el paso anterior:

cd klipper
make flash FLASH_DEVICE=2e8a:0003

Una vez ya tenemos el firmware aplicado lanzaremos el siguiente comando para obtener el serial ID (/dev/serial/by-id/xxx) que usaremos mas tarde en Klipper:

ls /dev/serial/by-id/

Ahora iremos a nuestro interfaz Klipper web para añadir la configuración del acelerómetro, del cual tenéis un ejemplo en https://github.com/bigtreetech/LIS2DW/blob/master/Firmware/sample-bigtreetech-lis2dw-v1.0.cfg ,

[mcu btt_lis2dw]
serial: /dev/serial/by-id/usb-Klipper_rp2040_btt_acc-if00

[lis2dw]
cs_pin: btt_lis2dw:gpio9
#spi_bus: spi1a
spi_software_sclk_pin: btt_lis2dw:gpio10
spi_software_mosi_pin: btt_lis2dw:gpio11
spi_software_miso_pin: btt_lis2dw:gpio8
axes_map: -y,x,-z

[resonance_tester]
probe_points: 100, 100, 20
accel_chip: lis2dw

Ajustaremos, de la configuración anterior, nuestro serial con el que obtivimos en el paso anterior y axes_map que indicara la dirección de movimientos de la máquina. Para más información sobre axes_map podéis revisar la documentación oficial de Klipper aquí. Básicamente es para indicar con respecto a la posicion del acelerómetro y el movimiento de la máquina... por ejemplo si colocamos el sensor con orientación Y para el eje de movimiento X usaremos y, x, z... y si lo tenemos invertido usaremos el simbolo - delante

Pasos para preparar y aplicar el firmware Klipper a nuestra Mellow FLY-USB accediento a nuestro host Klipper por SSH (PuTTy/Terminus):

El primer paso para preparar el dispositivo será aplicar el bootloader a nuestro FLY-USB, os aconsejamos seguir el procedimiento directamente desde la web de Mellow, no es complejo pero tenemos diferentes opciones.

https://mellow.klipper.cn/docs/ProductDoc/ToolBoard/fly-usb-adxl/fly-usb-lis2dw/blmellow.klipper.cn

Lanzaremos el comando para preparar nuestro firmware Klipper para nuestra BTT S2DW:

cd ~/klipper
make menuconfig

En la configuración del firmware seleccionaremos:

[*] Enable extra low-level configuration options
Micro-controller Architecture (Raspberry Pi RP2040/RP235x)  --->
Processor model (rp2040) --->
Bootloader offset (16KiB bootloader) --->
Communication interface (USBSERIAL)  --->
USB ids --->
(gpio24) GPIO pins to set at micro-controller startup

Presionaremos Q y luego Y para guardar los cambios
Reiniciaremos el servicio Klipper:

sudo service klipper stop

Haremos una limpieza de make para asegurarnos que todo está limpio

sudo make clean

Generaremos el firmware:

make

Hemos de disponer de katapult instalado en nuestro host, de no tenerlo podremos instalarlo lanzando

cd && git clone https://github.com/Arksine/katapult.git

Buscaremos el ID del dispositivo Mellow Fly utilizando lsusb Si no nos funciona el comando lsusb podemos instalarlo lanzando:
```
sudo apt-get install usbutils
```

ls /dev/serial/by-id/*

Nos anotaremos el ID del dispositivo el cual usaremos para lanzar el comando para actualizar el firmware

~/klippy-env/bin/python ~/katapult/scripts/flashtool.py -d /dev/serial/by-id/IC_Mellow

Si el firmware se aplico correctamente el led de la siguiente imagen se encenderá

Ahora iremos a nuestro interfaz Klipper web para añadir la configuración del acelerómetro, del cual tenéis un ejemplo en

Klipper参考配置 | FLY Docsmellow.klipper.cn

[mcu LIS]
serial: /dev/serial/by-id/usb-Klipper_rp2040_XXXXXXXXXXXXXXXXXXXXX

[lis2dw]
cs_pin: LIS:gpio9
spi_software_sclk_pin: LIS:gpio10
spi_software_mosi_pin: LIS:gpio11
spi_software_miso_pin: LIS:gpio12

[resonance_tester]
accel_chip: lis2dw
probe_points: 150, 150, 20
min_freq: 5
max_freq: 133
accel_per_hz: 75
hz_per_sec: 1

Ajustaremos, de la configuración anterior, nuestro serial con el que obtivimos en el paso anterior y axes_map que indicara la dirección de movimientos de la máquina. Para más información sobre axes_map podéis revisar la documentación oficial de Klipper aquí. Básicamente es para indicar con respecto a la posicion del acelerómetro y el movimiento de la máquina... por ejemplo si colocamos el sensor con orientación Y para el eje de movimiento X usaremos y, x, z... y si lo tenemos invertido usaremos el simbolo - delante

Gracias al compañero Xander de nuestro grupo Klipper de Telegram por ayudar en el proceso.

Muchas placas toolhead actuales como la BTT EBB SB2209, EBB SB2240, EBB36, EBB42 o la Mellow FLY-SB2040 incluyen un acelerómetro ADXL345 integrado en la propia placa. Si usas una de estas placas, no necesitas ningún acelerómetro externo — el sensor ya está ahí.

Esta es la opción más recomendada en máquinas CoreXY modernas (Voron 2.4, Trident, VzBot…) ya que el acelerómetro está montado directamente en el cabezal, muy cerca del nozzle, lo que da las medidas más precisas posibles.

La configuración es idéntica independientemente de si la placa toolhead se conecta por CAN bus o por USB. El acelerómetro siempre usa la MCU de la toolhead board como interfaz.

Configuración Klipper (ajusta el nombre EBBCan al que hayas definido en tu [mcu]):

[adxl345]
cs_pin: EBBCan:PB12
spi_software_sclk_pin: EBBCan:PB10
spi_software_mosi_pin: EBBCan:PB11
spi_software_miso_pin: EBBCan:PB2
axes_map: x, y, z

[resonance_tester]
accel_chip: adxl345
probe_points:
    150, 150, 20  # centro de tu cama, ajusta a tus dimensiones

Puedes añadir estos bloques directamente en printer.cfg o en un archivo separado adxl.cfg incluido desde printer.cfg:

# printer.cfg
[include adxl.cfg]

axes_map: el valor correcto depende de cómo esté orientada físicamente la placa en el cabezal. Para las EBB SB2209/SB2240 montadas en el Stealthburner de Voron, el valor habitual es x, y, z o -x, y, z dependiendo de la orientación. Si los resultados del test son extraños, prueba a ajustar este parámetro.

Para saber exactamente los pines SPI de tu placa toolhead específica consulta su configuración de ejemplo oficial:

Acelerómetros adicionales soportados nativamente por Klipper

Desde 2024 Klipper soporta dos sensores adicionales que vienen integrados en cada vez más toolhead boards:

LIS3DH — alternativa al LIS2DW, mismo fabricante (ST) y misma filosofía de uso. Se configura igual, soporta SPI o I2C. Habitual en placas SHT36/SHT42 de Mellow y similares.
ICM-20948 — de la familia MPU (Invensense/TDK), conexión I2C. Reemplazo natural del MPU-9250 con mejores prestaciones.

Hubo un bug inicial en el driver del ICM-20948 que dejaba el sensor en escala 2g por defecto en vez de 8g. Si tu Klipper es de finales de 2023 o principios de 2024, actualiza antes de calibrar — los valores serían incorrectos.

Configuración LIS3DH (SPI), ejemplo en una toolhead Mellow SHT36 v3:

[lis3dh]
cs_pin: SHT36:gpio9
spi_software_sclk_pin: SHT36:gpio10
spi_software_mosi_pin: SHT36:gpio11
spi_software_miso_pin: SHT36:gpio12
axes_map: x, y, z

[resonance_tester]
accel_chip: lis3dh
probe_points:
    125, 125, 20  # ajusta al centro de tu cama

Configuración LIS3DH (I2C):

[lis3dh]
i2c_mcu: SHT36
i2c_bus: i2c1
axes_map: x, y, z

[resonance_tester]
accel_chip: lis3dh
probe_points:
    125, 125, 20

Configuración ICM-20948 (I2C):

[icm20948]
i2c_mcu: rpi
i2c_bus: i2c.1
i2c_speed: 400000   # importante: el ICM-20948 trabaja a 400kHz
axes_map: x, y, z

[resonance_tester]
accel_chip: icm20948
probe_points:
    125, 125, 20

Comprobación rápida

Una vez añadida la configuración y reiniciado Klipper, ejecuta ACCELEROMETER_QUERY para verificar que el sensor responde correctamente y devuelve unos valores cercanos a 9800 mm/s² en uno de los ejes (la gravedad). Si no responde o los valores son extraños, revisa el cableado y el axes_map.

Tanto LIS3DH como ICM-20948 usan exactamente el mismo flujo de calibración que el ADXL345: TEST_RESONANCES, SHAPER_CALIBRATE, calibrate_shaper.py. Solo cambia la sección de configuración y el nombre del accel_chip.

Sobre puntos de sondeo Input Shaper.

Dentro de nuestra configuración de [resonance_tester] hay un parámetro muy importante a tener en cuenta... probe_points.

Normalmente, y dado que no vivimos en un mundo perfecto independientemente de la máquina que tengamos, las vibraciones mecánicas de nuestra máquina pueden y van a ser diferentes en distintas partes de nuestra impresora... por ejemplo el patrón de vibraciones puede NO ser, en especial dependiendo del tipo de cinemática, las mismas a diferentes alturas de Z o coordenadas de XY.

En estos casos puede ser aconsejable, al menos para ver el estado de nuestra máquina, el realizar testeos en diferentes puntos de nuestras coordenadas XY y Z.

en ejes X suele ser aconsejable añadir 3 coordenadas, 1/3 de X, 1/2 de X y 2/3 de X
aplicaremos en Y y Z la misma fórmula teniendo una malla de 21 puntos

Realizando este check podréis observar como afecta la ubicación de vuestro sensor a vuestras resonancias pudiendo identificar puntos de mejora.

Para un uso normal del test de Input Shaper suele ser suficiente con añadir en nuestro probe_points una malla de 9 puntos XY en una altura de 1/3 de Z, o en su defecto la altura máxima de nuestras impresiones si normalmente son más bajas que ese valor.

[resonance_tester]
accel_chip: adxl345 fysetc
probe_points:
    73,146,83 # point YrearXleft
    110,146,83 # point YrearXmidle
    146,146,83 # point YrearXright
    73,110,83 # point YmidleXleft
    110,110,83 # point YmidleXmidle
    146,110,83 # point YmidleXright
    73,73,83 # point YfrontXleft
    110,73,83 # point YfrontXmidle
    146,73,83 # point YfrontXright

Este proceso es aconsejable para usuarios avanzados que quieran averiguar el estado de su máquina e intentar ajustar/mejorar al máximo esta.

Instalando el software necesario en nuestro Klipper

Para procesar los datos del acelerómetro Klipper necesita algunas dependencias Python. La mayoría de distribuciones modernas (MainsailOS, FluiddOS, RatOS) las incluyen preinstaladas — si acabas de instalar desde una de ellas puedes pasar directamente a la sección de comprobaciones.

Si tienes una instalación antigua o una imagen base sin estas dependencias, instálalas por SSH:

# Dependencias del sistema
sudo apt update
sudo apt install python3-numpy python3-matplotlib libatlas-base-dev

# numpy en el entorno virtual de Klipper
~/klippy-env/bin/pip install -v numpy

En Raspberry Pi 3 o hardware similar este proceso puede tardar 10-15 minutos compilando numpy. Es normal — espera a que termine.

Si el comando anterior falla por versión de Python, prueba con:

~/klippy-env/bin/pip3 install -v numpy

Más información en la documentación de Klipper.

Comprobaciones

Con todo conectado iremos a la consola/terminal de nuestra UI de Klipper y ejecutaremos:

ACCELEROMETER_QUERY

En el caso que tengamos definido nuestro acelerómetro con un ID, como hicimos en el caso del Fysetc Pico, es necesario especificar el ID:

ACCELEROMETER_QUERY CHIP=fysetc

IMPORTANTE!!!

Es posible que al intentar la primera medida de nuestro acelerómetro, asegurándonos que previamente nuestra Pi Pico y/o nuestro Klipper ha sido reiniciado, puede dar errores.

Estos errores iniciales pueden pasar en el caso que nuestra comunicación SPI no se inicializó correctamente. Normalmente si esta todo bien configurado/conectado las siguientes medias deberían de funcionar.

En el caso que nos devuelva error deberemos:

revisar que nuestro cableado entre la Pi y nuestro acelerómetro sea el correcto y las conexiones mejor soldadas evitando conectores Dupont, JST pueden usarse ya que tienen mejor sujeción por norma general
que el cableado entre ambos no sea demasiado largo
en algunos casos raros y dependiendo la calidad del acelerómetro puede dar errores que puedes ver en la siguiente captura. En esos casos podemos mirar de desconectar el cable GND para ver si así funciona de forma correcta

Si obtenemos una respuesta como la siguiente el acelerómetro funciona correctamente!!!

adxl345 values (x, y, z): 6042.857730, 5507.414640, -5889.873990

Dado que el proceso genera bastante uso de MCU si usamos un Arduino y no es muy potente se pueded dar problemas de desconexiones.

Para evitar este problema bajaremos el parámetro rate a 1600 o 800 dentro de nuestra sección [adxl345].

Medición de resonancias

Ahora que ya tenemos todo configurado vamos a proceder a realizar nuestro test de resonancias.

En el caso que nuestra impresora sea Cartesiana, nuestra cama es un eje de movimiento, debereis realizar los tests en los ejes X e Y de forma independiente colocando vuestro acelerómetro bien anclado en el eje X y después moverlo al eje Y.

En el caso de una CoreXY no necesitamos cambiar el acelerómetro ya que anclando firmemente este a nuestro cabezal de impresión podremos medir ambos ejes.

A continuación podéis ver el modo manual aconsejado por Klipper, en nuetro caso y para que sea más sencillo la generación y uso de las gráficas os aconsejamos, aunque inicialmente tenga un poco más de trabajo, realizar este proceso usando macros shell.

En el caso que ya uses RatOS, que es de donde hemos obtenido esas macros/scripts, no es necesario tener que realizar esos pasos en tu configuración.

Test resonancias eje X

lanzaremos por consola/terminal desde nuestra UI el siguiente comando

TEST_RESONANCES AXIS=X

Test resonancias eje Y

lanzaremos por consola/terminal desde nuestra UI el siguiente comando

TEST_RESONANCES AXIS=Y

Podemos ajustar los rangos de nuestro test para obtener más detalle añadiendo los siguientes parámetros a nuestro TEST_RESONANCES:

FREQ_START=<min_freq>
FREQ_END=<max_freq>

https://www.klipper3d.org/G-Codes.html#test_resonances

En el caso que usemos los scripts que os aconsejamos anteriormente lanzar el proceso es muy sencillo tal como podéis ver en la siguiente imagen, al finalizar el proceso nos dejara las imágenes generadas en una carpeta input_shaper en la pestaña MACHINE en el caso que usemos Mainsail:

Es muy aconsejable, al menos durante la primera vez que lancemos el proceso, estar muy atentos a que las vibraciones provocadas por el test no sean muy violentas y puedan dañar nuestra impresora. Podéis usar el comando M112 o el botón EMERGENCY STOP en vuestra UI para parar el proceso.

Revisar los resultados

El proceso anterior generará dos ficheros CSV con los resultados del test.

También disponemos de una herramienta online para analizar estos CSV y generar estas gráficas al igual que las modificaciones en vuestro printer.cfg.

https://3dwork.io/tools/#shaper

Estos CSV se procesarán ejecutando (hay algunos scripts/macros que pueden simplificar la vida) los siguientes comandos desde el terminal SSH:

~/klipper/scripts/calibrate_shaper.py /tmp/resonances_x_*.csv -o /tmp/shaper_calibrate_x.png
~/klipper/scripts/calibrate_shaper.py /tmp/resonances_y_*.csv -o /tmp/shaper_calibrate_y.png

Un pequeño gran truco si no usáis los scrips que os aconsejamos más abajo...

A la hora de lanzar los comandos anteriores podemos modificar los parámetros del path de la imagen para dejarlo en nuestro /config, donde tenemos nuestro printer.cfg, accesible desde vuestra UI para poder verlo directamente sin tener que hacer nada.

Quedaría algo similar a esto, para un sistema Raspbian... adaptarlo si no es vuestro caso:

~/klipper/scripts/calibrate_shaper.py /tmp/resonances_x_*.csv -o /home/pi/printer_data/config/shaper_calibrate_x.png
~/klipper/scripts/calibrate_shaper.py /tmp/resonances_y_*.csv -o /home/pi/printer_data/config/shaper_calibrate_y.png

Estos scripts generarán unas imágenes con unas gráficas con información de las respuestas en frecuencia de nuestra máquina además de sugerirnos las más adecuadas:

Como interpretar los resultados

Un aspecto importante es interpretar los resultados que nos aportan las gráficas generadas de Input Shaper:

las lineas contínuas son las frecuencias medidas por el acelerómetro

las lineas de puntos representan la teórica reducción de vibraciones dependiendo del tipo de método de compensación de input shaper.

En cualquier caso os damos algunas sugerencias que pueden ayudar en el proceso.

la ubicación y anclaje del sensor es muy importante, aunque no es necesario estrictamente el ajuste de la orientación del sensor si que es aconsejable seguirla y dejar el sensor centrado en el cabezal de impresion a ser posible lo más cercano a la vertical del nozzle
generalmente buscamos que las líneas de puntos (estimación de reducción de vibraciones) se encuentren lo más bajas posibles en contraposición a las líneas continuas (lecturas de vibración del sensor)
las vibraciones por debajo de 25Hz no son buenas amigas.... básicamente porque las vibraciones a más altas frecuencias son más fáciles de cancelar, idealmente superiores a 50-70 Hz. Si las tienes es aconsejable revisar en detalle holguras/escuadras en el chasis, problemas de cinemática como correas poco o demasiado tensas... básicamente porque van a limitar bastante las aceleraciones de la máquina
lo ideal es que las graficas no tengan doble o más picos siendo lo ideal una onda como podéis ver en la imagen del video de abajo. En el caso de tenerlas revisar holguras además de tensiones de correas. Aunque no siempre tiene porqué ser así ya que es importante fijarse en la escala y sus magnitudes.
En máquinas CoreXY el rango de frecuencias debería de ser muy similar en ambos casos aunque normalmente el eje Y suele estar un poco más bajo que el X

Además de lo anterior es importante, con referencia al tipo de Input Shaper sugerido, que tengamos en cuenta los siguientes puntos:

los tipos 2HUMP_EI y 3HUMP_EI normalmente se sugieren cuando nuestras gráficas tengan varias puntas de resonancias, picos en nuestra onda, por lo que si se os sugieren este tipo de Input Shaper lo ideal es revisar nuestro chásis (sin holguras y escuadrado), mecánica (motores con su configuración óptima y bien anclados) y cinemática (tensado y alineado de correas, poleas en buen estado, lubricación, ajuste excéntricas) para intentar mitigar esos picos de vibraciones. Por lo anterior son los métodos idealmente a evitar usar ya que indicaría que nuestra máquina estructuralmente pueda tener deficiencias. En el siguiente ejemplo veréis una máquina sin ajuste de correas como aparece la gráfica y el tipo que suguiere de input shaper y una vez tensadas correctamente las correas:

Normalmente los Input Shaper más aconsejables son MZV y EI
- EI normalmente suele ser el más adecuado para máquinas Cartesianas (el eje Y, cama, se desplaza) y Delta ya que se comporta mejor con cambios en resonancias en la máquina.
- MZV o ZV normalmente funcionan mejor en máquinas CoreXY

Teniendo en cuenta lo anterior nuestro consejo sería realizar el test de resonancias impreso usando el sugerido por el test del acelerómetro y, si no coincide, con el aconsejable para nuestra máquina para ver las diferencias entre ellos ante un test real.

Smoothing/Alisado

Por último nos gustaría comentar que Input Shaper puede llegar a generar unas piezas "alisadas" en exceso afectando al acabado final de esta y sus detalles por lo que en estos casos que el algoritmo elige una frecuencia que no es óptima podemos optar por aplicar menos alisado con el coste de incrementar las resonancias.

Dependiendo del tipo de Input Shaper seleccionado:

ZV/MZV/EI, suelen tener unos valores bajos de smooth por lo que es un tipo adecuado para no requerir un ajuste fino de alisado
2HUMP_EI/3HUMP_EI, suelen tener unos altos valores de smooth por lo que si no nos queda mas remedio que usarlo es aconsejable un ajuste fino de alisado

Para realizar un ajuste fino de smooth/alisado cuando usamos Input Shaper:

Teniendo el siguiente resultado de un test normal:

Vemos que ZV apenas tiene smoothing/alisado, MZV/EI tienen unos valores medios de smoothing/alisado, y 2HUMP_EI/3HUMP_EI tienen unos valores altos.

En el caso que usemos unos de estos tipos con medio/alto smoothing/alisados podremos intentar ver como reducir este lanzando una simulación limitando el valor máximo de smoothing, lo que nos adaptará para aquellos que superen ese valor máximo de smoothing los valores calculados. Añadiremos el valor smoothing máximo deseado, --max_smoothing=0.2 en la parte final, en el siguiente script :

~/klipper/scripts/calibrate_shaper.py /tmp/resonances_x_*.csv -o /tmp/shaper_calibrate_x.png --max_smoothing=0.2

Comparando ambos resultados veremos que tenemos más resonancias pero el valor de alisado/smoothing es mucho mejor algo que afectará a las las aceleraciones de Input Shaper.

Una vez tengamos el valor de max_smooth deseado lo meteremos en la sección [resonance_tester] y recordad actualizar las aceleraciones máximas de la impresora tal y como las calculamos en puntos anteriores ya que con este ajuste suelen cambiar:

[resonance_tester]
accel_chip: ...
probe_points: ...
max_smoothing: 0.25  # an example

En el caso que usemos el test automático de resonancias que explicamos mas abajo, SHAPER_CALIBRATE, usará el valor de max_smoothing como referencia para lanzar el test.

Como siempre os aconsejamos realizar varios tests en real para encontrar el balance en vuestra máquina y piezas impresas que se ajusten más a vuestras necesidades.

Videos interesantes en referencia a como interpretar la información del proceso Input Shaper

A continuación podéis ver estos videos que pueden ayudar a comprender estas gráficas:

Añadir la información de Input Shaper en nuestra configuración

Una vez ya tenemos la configuración sugerida para nuestra máquina añadiremos esta a nuestro printer.cfg en la sección [input_shaper] y actualizaremos las aceleraciones máximas de nuestro [printer]

## ejemplo de valores input shaper para Y según gráfica anterior
[input_shaper]
shaper_freq_x: ...
shaper_type_x: ...
shaper_freq_y: 34.6
shaper_type_y: mzv

En el caso de las acceleraciones máximas es aconsejable seleccionar el valor que no supere los valores calculados en el ejes X e Y (usaremos el más bajo de ellos) además de añadir un cierto margen de seguridad como por ejemplo el 90% del valor que obtuvimos en los tests (de nuevo sobre el eje que nos dio el valor más bajo):

## actualizacion de aceleraciones max que no deberia superar los valores maximos de aceleracion obtenidos en X e  Y
[printer]
max_accel: 3000

Ajuste automático de valores de resonancia por Klipper

El siguiente proceso es aconsejable realizarlo en el caso que antes realicemos el proceso anterior prestando especial atención en ajustar nuestra máquina para encontrar el punto óptimo de nuestra máquina para obtener los mejores resultados de Input Shaper.

Aunque usemos el método que suerimos a continuación os recomendamos de forma periódica o cuando ajustemos algo en la máquina a nivel mecánico realizar el proceso manual para volver a ajustarla correctamente.

Klipper dispone de una macro que ejecuta los tests de Input Shaper y seleccionará de forma automática, y en ocasiones no tienen porqué ser los más óptimos, los ajustes de Input Shaper.

Lanzaremos desde nuestro terminal la siguiente macro:

En el caso de máquinas CoreXY o si disponemos de 2 acelerómetros instalados y configurados para X e Y:

SHAPER_CALIBRATE

En el caso que tengamos una máquina no CoreXY y que tengamos que medir de forma independiente cada eje lanzaremos la macro especificando cada eje a testear:

SHAPER_CALIBRATE AXIS=X
SHAPER_CALIBRATE AXIS=Y

Al igual que el proceso manual lanzará el proceso Input Shaper y nos generará nuestro csv en /tmp/calibration_data_*.csv y nos indicará en el terminal también la información del test:

Calculating the best input shaper parameters for y axis
Fitted shaper 'zv' frequency = 39.0 Hz (vibrations = 13.2%, smoothing ~= 0.105)
To avoid too much smoothing with 'zv', suggested max_accel <= 5900 mm/sec^2
Fitted shaper 'mzv' frequency = 36.8 Hz (vibrations = 1.7%, smoothing ~= 0.150)
To avoid too much smoothing with 'mzv', suggested max_accel <= 4000 mm/sec^2
Fitted shaper 'ei' frequency = 36.6 Hz (vibrations = 2.2%, smoothing ~= 0.240)
To avoid too much smoothing with 'ei', suggested max_accel <= 2500 mm/sec^2
Fitted shaper '2hump_ei' frequency = 48.0 Hz (vibrations = 0.0%, smoothing ~= 0.234)
To avoid too much smoothing with '2hump_ei', suggested max_accel <= 2500 mm/sec^2
Fitted shaper '3hump_ei' frequency = 59.0 Hz (vibrations = 0.0%, smoothing ~= 0.235)
To avoid too much smoothing with '3hump_ei', suggested max_accel <= 2500 mm/sec^2
Recommended shaper_type_y = mzv, shaper_freq_y = 36.8 Hz

En el caso que nos parezcan bien los parámetros sugeridos ejecutaremos la macro SAVE_CONFIG y reniciar Klipper. Recuerda que este proceso no ajusta el max_accel de la sección [printer] que deberemos ajustar manualmente tal como hicimos anteriormente.

El proceso de Input Shaper NO es aconsejable realizarlo de forma frecuente, ponerlo al inicio de cada impresion por ejemplo no suele ser buena idea.

El proceso de Input Shaper genera una serie de vibraciones extremas que pueden llegar a dañar o desajustar nuestra impresora.

Calibración en una sola pasada (single pass)

Esta funcionalidad ya estaba disponible pero ha pasado a estar bien documentada y soportada de forma estable en Klipper. Si tu impresora monta dos acelerómetros (uno en el cabezal y otro en la cama, o uno por toolhead en multi-extrusor) puedes calibrar los dos ejes a la vez sin tener que mover físicamente el sensor.

Habitualmente en una cartesiana (bed slinger) hay que ejecutar SHAPER_CALIBRATE AXIS=X y luego SHAPER_CALIBRATE AXIS=Y moviendo el acelerómetro entre el cabezal y la cama. Con dos acelerómetros ese paso desaparece: Klipper mide ambos ejes simultáneamente en una única ejecución.

Configuración con dos acelerómetros (ej. ADXL345):

[adxl345 hotend]
cs_pin: rpi:None     # u otro pin SPI del cabezal
spi_speed: 5000000
spi_bus: spidev0.0

[adxl345 bed]
cs_pin: MCU:PA4      # un segundo SPI, en este ejemplo en la MCU principal

[resonance_tester]
accel_chip_x: adxl345 hotend
accel_chip_y: adxl345 bed
probe_points:
    100,100,20

Date cuenta del cambio respecto a la configuración estándar: ya no se usa accel_chip:, sino accel_chip_x: y accel_chip_y:. Klipper sabe automáticamente qué acelerómetro corresponde a cada eje y, al lanzar SHAPER_CALIBRATE sin el parámetro AXIS=..., calibra ambos en una sola pasada:

SHAPER_CALIBRATE
SAVE_CONFIG

Variante con dos MPU-9250 / ICM-20948 (I2C):

Como ambos chips comparten bus, hay que jugar con i2c_address (pin AD0 a GND o a VCC):

[mpu9250 hotend]
i2c_address: 104   # AD0 a GND

[mpu9250 bed]
i2c_address: 105   # AD0 a VCC

[resonance_tester]
accel_chip_x: mpu9250 hotend
accel_chip_y: mpu9250 bed
probe_points:
    100,100,20

Otra mejora importante de SHAPER_CALIBRATE — desde mediados de 2023 los valores calculados se aplican al instante si ya tienes una sección [input_shaper] en tu printer.cfg. Antes hacía falta un RESTART después de SAVE_CONFIG. Hoy puedes lanzar el test, revisar la gráfica e imprimir un test inmediatamente con los nuevos valores ya activos, y solo guardarlos definitivamente cuando estés convencido.

Sweeping vibrations — método de medición mejorado (Klipper 0.13+)

A partir de Klipper v0.13.0 (abril 2025) se introdujo un nuevo método de medición de resonancias llamado sweeping vibrations. El proceso clásico generaba vibraciones a frecuencia fija con el cabezal parado en un único punto; el nuevo método superpone un movimiento lento de barrido (sweep) mientras se inyectan las vibraciones, de forma que el cabezal recorre una pequeña área en lugar de quedarse quieto.

¿Qué mejora respecto al test clásico?

Excita mejor los modos de resonancia mecánica, especialmente los que dependen de la posición del cabezal.
Reduce los falsos positivos cuando justo el punto de sondeo coincide con una zona con fricción anómala o una holgura local.
Detecta resonancias a frecuencias ligeramente más bajas que el método antiguo, normalmente más cercanas al comportamiento real durante una impresión.

Cómo activarlo

El nuevo método se controla mediante dos parámetros en la sección [resonance_tester]:

[resonance_tester]
accel_chip: adxl345
probe_points:
    100,100,20
# Sweeping vibrations
sweeping_accel: 400      # mm/sec² del barrido (valor por defecto razonable)
sweeping_period: 1.2     # periodo del barrido en segundos

sweeping_period: 0 (valor por defecto) → desactivado, se usa el método clásico de toda la vida.
sweeping_period > 0 → activa el barrido. La amplitud del recorrido durante el test es aproximadamente sweeping_accel * sweeping_period² / 32 (con los valores del ejemplo, unos 18 mm).

No hace falta cambiar los comandos: se siguen usando TEST_RESONANCES, SHAPER_CALIBRATE, etc. La diferencia es interna: con sweeping_period distinto de 0, Klipper añade el barrido al test.

Si tu impresora tiene poco espacio útil alrededor del punto de sondeo (cabezales grandes, accesorios cerca del nozzle...) asegúrate de que la amplitud del barrido no provoca colisiones. Reduce sweeping_accel y/o sweeping_period si es el caso, o vuelve al método clásico con sweeping_period: 0.

Recomendación 3Dwork: si vienes del método antiguo, prueba primero los valores por defecto del sweeping y compara los resultados con tu calibración previa. En la mayoría de máquinas el método nuevo da unas gráficas más limpias y unos parámetros más conservadores (y por tanto, más estables en uso diario).

Automatizando el test de resonancias

El proceso anterior es el aconsejado por Klipper pero gracias a los amigos de Ratrig con su RatOS podemos aprovechar algunas partes para automatizar el proceso y que simplemente con unos clicks desde nuestra UI podamos realizar el proceso de forma mucho más cómoda.

Para que Klipper pueda ejecutar shell macros se ha de instalar una extensión, gracias al compañero Arksine, que lo permita.

Dependiendo de la distro de Klipper usada pueden venir ya habilitadas.

La forma más sencilla es usando Kiauh donde encontraremos en una de sus opciones la posibilidad de instalar esta extensión:

También podemos realizar el proceso a mano copiaremos manualmente el plugin para Klipper gcode_shell_extension dentro de nuestro directorio ~/klipper/klippy/extras usando SSH o SCP y reiniciamos Klipper.

Creando nuestros scripts de test de resonancias

Para seguir con la misma estructura que tiene RatOS lo ideal es crear una carpeta "scripts" en nuestro directorio de configuraciones Klipper donde crearemos los siguientes ficheros.

generate-shaper-graph-x.sh - para generar gráficas del eje X

generate-shaper-graph-x.sh - https://github.com/Rat-OS/RatOS-configuration/blob/master/scripts/generate-shaper-graph-x.sh

#!/bin/bash

NEWX=$(ls -Art /tmp/resonances_x_*.csv | tail -n 1)
DATE=$(date +'%Y-%m-%d-%H%M%S')
if [ ! -d "/home/pi/printer_data/config/input_shaper" ]
then
    mkdir /home/pi/printer_data/config/input_shaper
    chown pi:pi /home/pi/printer_data/config/input_shaper
fi

~/klipper/scripts/calibrate_shaper.py $NEWX -o /home/pi/printer_data/config/input_shaper/resonances_x_$DATE.png

generate-shaper-graph-y.sh - para generar gráficas del eje Y

#!/bin/bash

NEWY=$(ls -Art /tmp/resonances_y_*.csv | tail -n 1)
DATE=$(date +'%Y-%m-%d-%H%M%S')
if [ ! -d "/home/pi/printer_data/config/input_shaper" ]
then
    mkdir /home/pi/printer_data/config/input_shaper
    chown pi:pi /home/pi/printer_data/config/input_shaper
fi

~/klipper/scripts/calibrate_shaper.py $NEWY -o /home/pi/printer_data/config/input_shaper/resonances_y_$DATE.png

generate-belt-tension-graph.sh - para generar gráficas de tensión de correas (CoreXY aconsejable)

#!/bin/bash
set -e -u -o pipefail

## the TEST_RESONANCES command seems to return before all data is completely
## written. it'd be better to poll for the files to be completely written,
## but this has been reliable for me so far…
sleep 10

outdir=/home/pi/printer_data/config/input_shaper
if [ ! -d "${outdir}" ]; then
    mkdir "${outdir}"
fi

~/klipper/scripts/graph_accelerometer.py \
    -c /tmp/raw_data_axis*_belt-tension-*.csv \
    -o "${outdir}/belt-tension-resonances-$( date +'%Y-%m-%d-%H%M%S' ).png"

Estos scripts se usarán por nuestras nuevas macros para generar las gráficas con los resultados de nuestros tests de input shaper.

Es importante recordar que si los path indicados o usados en los scripts no coinciden con tu instalación deberás adaptarlos.

Además asegúrate que tus scripts tienen permisos de ejecución con el comando chmod +x nombre_fichero.sh desde SSH

Creando nuestras nuevas macros para input shaper

Ahora que ya tenemos nuestros scripts listos crearemos nuestras macros de gestion de input shaper.

Para ello y a la altura de nuestro printer.cfg crearemos un nuevo fichero shell-macros.cfg donde añadiremos nuestras macros que usen scripts, dado que Klipper tiene un sistema modular creemos que es la mejor forma para que quede todo más limpio y fácil de tener la configuración de nuestra máquina ordenada.

shell-macros.cfg

[gcode_shell_command generate_shaper_graph_x]
command: /home/pi/printer_data/config/scripts/generate-shaper-graph-x.sh
timeout: 60.
verbose: True

[gcode_shell_command generate_shaper_graph_y]
command: /home/pi/printer_data/config/scripts/generate-shaper-graph-y.sh
timeout: 60.
verbose: True

[gcode_shell_command generate_belt_tension_graph]
command: /home/pi/printer_data/config/scripts/generate-belt-tension-graph.sh
timeout: 90.
verbose: True

[gcode_macro GENERATE_SHAPER_GRAPHS]
description: Genarates input shaper resonances graphs for analysis. Uses the AXIS parameter for if you only want to do one axis at a time, (eg. GENERATE_SHAPER_GRAPHS AXIS=X)
gcode:
    {% if params.AXIS is defined %}
        {% if params.AXIS|lower == 'x' %}
            G28
            TEST_RESONANCES AXIS=X
            RUN_SHELL_COMMAND CMD=generate_shaper_graph_x
            RESPOND MSG="Input shaper graph generated for the X axis. You'll find it in the input_shaper folder in the machine tab!"
        {% elif params.AXIS|lower == 'y' %}
            G28
            TEST_RESONANCES AXIS=Y
            RUN_SHELL_COMMAND CMD=generate_shaper_graph_y
            RESPOND MSG="Input shaper graph generated for the Y axis. You'll find it in the input_shaper folder in the machine tab!"
        {% else %}
            {action_raise_error("Unknown axis specified. Expected X or Y.")}
        {% endif %}
    {% else %}
        G28
        TEST_RESONANCES AXIS=X
        TEST_RESONANCES AXIS=Y
        RUN_SHELL_COMMAND CMD=generate_shaper_graph_x
        RUN_SHELL_COMMAND CMD=generate_shaper_graph_y
        RESPOND MSG="Input shaper graphs generated for X and Y. You'll find them in the input_shaper folder in the machine tab!"
    {% endif %}
    
[gcode_macro MEASURE_COREXY_BELT_TENSION]
description: Generates resonance graph used to ensure belts are equally tensioned.
gcode:
    TEST_RESONANCES AXIS=1,1  OUTPUT=raw_data NAME=belt-tension-upper
    TEST_RESONANCES AXIS=1,-1 OUTPUT=raw_data NAME=belt-tension-lower
    RUN_SHELL_COMMAND CMD=generate_belt_tension_graph
    RESPOND MSG="Belt tension graphs generated. You'll find them in the input_shaper folder in the machine tab!"

Estas macros utilizan la macro de sistema RESPOND para notificaciones, en el caso que te de problemas asegúrate que tienes la sección [respond] en tu printer.cfg.

Con esto evitaremos el error en el terminal // Unknown command:"RESPOND"

Recordad que para que estas macros estén disponibles en Klipper hemos de añadir mediante include del fichero shell-macros.cfg creado anteriormente:

printer.cfg

...
[include shell-macros.cfg]
...

Estas nuevas macros se encargan de:

GENERATE_SHAPER_GRAPHS, lanzará el proceso de generar test de resonancias y las gráficas de input shaper para ambos ejes de forma automatizada (o de uno en concreto si así se lo indicas como parámetro) y nos dejara las imagenes dentro de la carpeta input shaper para poderlas bajar de forma cómoda desde nuestra UI
MEASURE_COREXY_BELT_TENSION, generará las gráficas de tensión de correas aconsejable en el caso de máquinas CoreXY

Klippain Shake&Tune — análisis avanzado de resonancias

Klippain Shake&Tune es una extensión de Klipper desarrollada por Frix-x que va mucho más allá del proceso estándar. Genera gráficas más detalladas, analiza la condición mecánica de la máquina y detecta problemas como correas desiguales o holguras.

¿Qué añade respecto al proceso estándar?

Gráficas más completas: frecuencias, picos de resonancia, nivel de ruido y estimación de smoothing en una sola imagen
Análisis de correas (CoreXY): compara las resonancias de ambas correas para detectar desequilibrios
Análisis del sistema de extrusión: detecta vibraciones en el motor del extrusor que pueden afectar a la calidad
Diagnóstico mecánico: pistas sobre qué ajustar si los resultados son malos (holguras, correas, tornillos)
Macros integradas desde la UI de Mainsail/Fluidd: no hace falta SSH para nada

Instalación

cd ~/
git clone https://github.com/Frix-x/klippain-shaketune.git

Añade en tu moonraker.conf:

[update_manager Klippain-ShakeTune]
type: git_repo
origin: https://github.com/Frix-x/klippain-shaketune.git
path: ~/klippain-shaketune
virtualenv: ~/klippy-env
requirements: requirements.txt
system_dependencies: system-dependencies.json
primary_branch: main
managed_services: klipper

Añade en tu printer.cfg:

[shaketune]
# result_folder: ~/printer_data/config/ShakeTune_results
# number_of_results_to_keep: 3
# keep_raw_csv: False
# show_macros_in_webui: True
# timeout: 300

Macros disponibles

Una vez instalado tendrás estas macros disponibles desde la UI:

Macro

Descripción

AXES_MAP_CALIBRATION

Detecta automáticamente el axes_map correcto del acelerómetro

COMPARE_BELTS_RESPONSES

Compara resonancias de correas A y B (CoreXY)

EXCITATE_AXIS_AT_FREQ

Excita un eje a una frecuencia para buscar holguras físicamente

AXES_SHAPER_CALIBRATION

Test completo de resonancias con gráficas avanzadas

CREATE_VIBRATIONS_PROFILE

Crea el perfil de vibraciones para Klipper

Recomendado para usuarios de Voron, VzBot y cualquier CoreXY moderno. La macro COMPARE_BELTS_RESPONSES es especialmente útil para asegurarse de que ambas correas están igual de tensadas antes de calibrar Input Shaper.

Para más información y documentación completa: https://github.com/Frix-x/klippain-shaketune

Método manual sin acelerómetro.

Compensación de resonancias manual, en este caso y mediante una torre de test podremos encontrar y ajustar los valores de Input Shaping siguiendo las instrucciones del link anterior.

Ajustes en el laminador para nuestra pieza de test:

Ajustaremos altura de capa a 0.2
Pondremos a 0 el relleno y capas superiores
Perímetros en 1 y a ser posible imprimir en modo vaso, 2 máximo si no usamos modo vaso
Perímetros externos entre 80-120mm/s, dependiendo de la calidad de nuestra máquina y la calidad de chasis/mecánica/cinemática... es aconsejable hacer el test a 80, 100, 120mm/s para ver en que rangos se comporta mejor la máquina.
Tiempo mínimo de capa 3 segundos, como mucho idealmente 0.
Deshabilitar cualquier función de gestión o límites de aceleraciones en el laminador.
No girar el modelo de test, está hecho para que cada cara coincida con el eje a probar.

Desde la consola de nuestra UI web de Klipper:

Si tenemos personalizado el valor square_corner_velocity lo dejaremos por defecto a 5.0
Deshabilitaremos minimum_cruise_ratio para que no limite las aceleraciones del test: SET_VELOCITY_LIMIT MINIMUM_CRUISE_RATIO=0
Ajustaremos Pressure Advance a 0 con SET_PRESSURE_ADVANCE ADVANCE=0.
Deshabilitaremos Input Shaper SET_INPUT_SHAPER SHAPER_FREQ_X=0 SHAPER_FREQ_Y=0. Si nos diera error no hemos de preocuparnos y continuamos con el siguiente paso.
En el caso que queramos testear un tipo de compensación Input Shaper usaremos SET_INPUT_SHAPER SHAPER_TYPE=MZV sustituyendo SHAPER_TYPE por el que queramos testear
Ejecutaremos: TUNING_TOWER COMMAND=SET_VELOCITY_LIMIT PARAMETER=ACCEL START=1500 STEP_DELTA=500 STEP_HEIGHT=5. Con este comando incrementamos cada 5mm la aceleración hasta finalizar la prueba de test en 7000 mm/s.

Si creemos que nuestra máquina puede moverse correctamente con aceleraciones superiores podemos ajustar el test con estos parámetros:

ACCEL START=1500
STEP_DELTA=500
STEP_HEIGHT=5

Una vez finalizado el test procederemos a analizar los resultados:

Aunque es obvio, usaremos las letras que aparecen en la pieza de test para identificar en que eje realizaremos los ajustes que obtengamos.
Usando un calibre de precisión mediremos la distancia entre varias oscilaciones como vemos en la imagen superior, obviaremos las series a mayor aceleraciones que tengan estas oscilaciones más marcadas y mediremos la distancia total entre 6-8 oscilaciones
Calcularemos la frecuencia de cada eje usando la siguiente fórmula:

V*N/D=Hz

V es la velocidad que usamos en los perímetros externos. N es el número de oscilaciones medidas. D es la distancia entre ellas. A modo de ejemplo, para un test a 100mm/s, medimos 8 oscilaciones con una distancia de 19mm: 100*8/19= 42 Hz

Input Shaper configuración en Klipper

Editaremos nuestro printer.cfg
Añadiremos la siguiente sección:

[input_shaper]
shaper_freq_x: ... # frequencia X calculada
shaper_freq_y: ... # frequencia Y calculada

Guardaremos los cambios y reiniciaremos Klipper.

Ahora que ya tenemos identificadas las frecuencias óptimas para nuestra máquina deberemos encontrar el tipo de Input Shaper adecuado para nuestra máquina.

Klipper, como tenéis más adelante explicado en detalle, cuenta con diferentes tipos de Input Shaper como MZV, EI, 2HUMP_EI, o 3HUMP_EI.

Para encontrar el tipo de Input Shaper adecuado:

Ejecutaremos los siguientes comando en consola para verificar nuestra configuración usando MZV como tipo de Input Shaper:

SET_VELOCITY_LIMIT MINIMUM_CRUISE_RATIO=0
SET_PRESSURE_ADVANCE ADVANCE=0
SET_INPUT_SHAPER SHAPER_TYPE=MZV
TUNING_TOWER COMMAND=SET_VELOCITY_LIMIT PARAMETER=ACCEL START=1500 STEP_DELTA=500 STEP_HEIGHT=5

Volveremos a imprimir la torre de test que realizamos en el paso anterior.

Reiniciaremos el sistema Klipper y nuestra máquina al finalizar y lanzaremos los siguientes comandos en consola para verificar nuestra configuración con EI como tipo de Input Shaper:

SET_VELOCITY_LIMIT MINIMUM_CRUISE_RATIO=0
SET_PRESSURE_ADVANCE ADVANCE=0
SET_INPUT_SHAPER SHAPER_TYPE=EI
TUNING_TOWER COMMAND=SET_VELOCITY_LIMIT PARAMETER=ACCEL START=1500 STEP_DELTA=500 STEP_HEIGHT=5

Volveremos a imprimir la torre de test y una vez finalizado el proceso comprobaremos ambas impresiones para ver cual de ellas ha mejorado en calidad. En el caso que no veamos mejoras lanzaremos los tests para 2HUMP_EI y 3HUMP_EI aunque os adelantamos que si con estos vemos mejoras suele indicar que nuestra impresora pueda tener problemas mecánicos los cual se deberían revisar. Para elegir uno u otro se han de ajustar la línea de comandos SET_INPUT_SHAPER SHAPER_TYPE= añadiendo al final los tipos que queramos testear de uno en uno.

Una vez tengamos seleccionado el input shaper adecuado para nuestra máquina ajustaremos nuestra configuración de Klipper:

[input_shaper]
shaper_freq_x: ... # frequencia X calculada
shaper_freq_y: ... # frequencia Y calculada
shaper_type: ... # el tipo de input shaper MZV, EI, 2HUMP_EI, o 3HUMP_EI

Guardaremos los cambios y reiniciaremos Klipper.

Otro paso aconsejable es ajustar la aceleaceleraciónración máxima ya que, en especial dependiendo del tipo de Input Shaper y tal como tenéis explicado con más detalle más adelante, una aceleración muy alta o muy baja puede llegar a "matar"/alisar detalles de nuestras impresiones.

Ya tenemos nuestro Input Shaper calculado, podemos verificar resultados repitiendo la pieza de test pero saltando el punto 3 dentro de la parte de comandos en consola evitando de esa forma deshabilitar Input Shaper.

Para encontrar el valor óptimo para nuestro caso volveremos a revisar la torre donde elegimos el tipo de Input Shaper para revisar:

Verificaremos donde la hendidura donde comience a ampliarse. La torre de test comienza con aceleración de 1500 mm/S2 y lo aumenta en 500 mm/S2 a cada intervalo de 5 mm. En la imagen anterior (que está rotada de 90 grados), puedes ver que el espacio se amplía y ve un hueco entre las trazadas de capa a aproximadamente 20-25 mm de altura. Esto indica que la mejor configuración de aceleración sería entre 3000-3500 mm/S2. Seleccionaremos el valor más bajo del último rango que salga correctamete, 3000 mm/s2 para la imagen anterior.
Iremos a nuestra configuración de Klipper y dentro de la sección [printer] añadiremos o actualizaremos el valor de max_accel al valor óptimo, para el caso anterior max_accel: 3000 .

Si obtenemos un buen resultado podemos empezar a imprimir con un punto más de velocidad sin tener artefactos en nuestras impresiones!!!

Recuerda que para ello te aconsejamos revisar la velociada máxima de tu máquina y tests en real con tus piezas para un ajuste fino.

AnteriorPressure Advance

SiguienteVelocidad Máxima

Última actualización hace 4 meses