Neopixel

Configuración completa de LEDs inteligentes en Klipper: desde la conexión a la MCU principal hasta opciones avanzadas con WLED, LUMEN o una segunda MCU dedicada.

Klipper tiene soporte nativo para tiras LED inteligentes WS2812/SK6812 (Neopixel) y APA102/SK9822 (Dotstar), más integración con WLED y LUMEN a través de Moonraker. Con esto puedes iluminar el cerramiento, mostrar el progreso de impresión en tiempo real con colores, animar el toolhead o simplemente saber de un vistazo en qué estado está la máquina.

Esta guía cubre las tres opciones de conexión de menos a más avanzada. Si ya tienes los LEDs funcionando y solo buscas efectos, salta a LED Effects o a la sección de hardware externo.

Dónde conseguir tiras LED Neopixel

WS2812B 5V (más común)

AliExpress - Online Shopping for Popular Electronics, Fashion, Home & Garden, Toys & Sports, Automobiles and More.AliExpress - Online Shopping for Popular Electronics, Fashion, Home & Garden, Toys & Sports, Automobiles and More.

SK6812 RGBW 5V

Si utilizas los links de compra, el precio del producto será el mismo que si accedes de manera habitual, pero a 3DWork le quedará una pequeña comisión. Algo que nos ayudará a soportar el proyecto y continuar generando contenido.

Antes de conectar — instalación física

Puntos críticos antes de conectar cualquier tira LED:

• Añade una resistencia de 300-500 Ω entre el pin de señal de la MCU y el pin de datos de la tira. Protege la MCU de picos en el bus de datos. Sin ella puedes quemar el pin.

• Las tiras tienen dirección — la alimentación y la señal van en el sentido de la flecha marcada en la PCB.

  
• Alimenta externamente con una fuente 5V dedicada si tienes más de 15-20 LEDs. La mayoría de electrónicas (SKR, Octopus, Manta) solo aguantan eso antes de necesitar corriente extra. Superar el límite provoca reinicios aleatorios de la MCU.

• GND común obligatorio — conecta el GND de la tira y el GND de la MCU al mismo punto. Sin esto la señal de datos no llega bien y los LEDs hacen cosas raras.

• Para calcular el consumo exacto: WLED Power Calculator

Tipos de LED y su color_order

Este parámetro es el origen de la mayoría de problemas con colores incorrectos. Cada tipo de LED envía los bytes de color en un orden distinto:

LED	Protocolo	color_order	Notas
WS2812B	1 cable (datos)	GRB	El más común en impresoras 3D
WS2812B con blanco	1 cable (datos)	GRBW	4 canales
SK6812 RGBW	1 cable (datos)	GRBW	Muy usado en tiras de cerramiento
SK6812 RGB	1 cable (datos)	GRB	Sin canal blanco
APA102 / SK9822	2 cables (datos + reloj)	BGR	Más robusto, mejor para tiras largas
Dotstar (Adafruit)	2 cables (datos + reloj)	BGR	Mismo chip que APA102
WS2811	1 cable (datos)	RGB	Cuidado: orden diferente al WS2812

Si pides rojo y salen verdes, o azul y salen otra cosa, el problema es el color_order. Prueba los valores hasta que los colores sean correctos.

También puedes especificar un color_order diferente para cada LED de la cadena si mezclas tipos distintos: color_order: GRB, GRB, GRBW

---

Opción 1 — Conexión a la MCU principal

La forma más directa: conectar la tira al pin RGB de tu electrónica (Octopus, SKR, Manta…) y dejar que Klipper la gestione. Sin hardware extra, configuración en printer.cfg y control total desde macros y LED Effects.

Klipper no soporta Neopixel conectados directamente a los GPIO de la Raspberry Pi cuando se usa como Linux MCU. El kernel de Linux no tiene la precisión de temporización necesaria para el protocolo WS2812. Si quieres usar los GPIO de la Pi, ve a la sección LUMEN o Segunda MCU RP2040.

Configuración en printer.cfg

Lo más limpio es crear un archivo separado led_effects.cfg y referenciarlo desde printer.cfg:

# En printer.cfg
[include led_effects.cfg]

Así mantienes el cfg principal ordenado y puedes tocar la configuración de LEDs sin tocar el resto.

WS2812 / Neopixel

El más común en impresoras 3D. Un único cable de datos, protocolo de 1 hilo.

[neopixel mi_tira_led]
pin: PA1                  # Pin de datos — ajusta a tu electrónica
chain_count: 15           # Número de LEDs en la tira
color_order: GRB          # Estándar WS2812B — cambia si los colores salen mal
initial_RED: 0.5
initial_GREEN: 0.5
initial_BLUE: 0.5
initial_WHITE: 0.0        # Solo para LEDs RGBW

SK6812 RGBW

APA102 / Dotstar

Pines LED en electrónicas BTT habituales

Electrónica	Conector	Pin Klipper
BTT Octopus v1.x	RGB header	PB0
BTT Manta M4P / M5P / M8P	RGB1	PD0
BTT SKR 3	RGB	PE2
BTT SKR Mini E3 v3	Neopixel	PC7

Los manuales de BTT a veces tienen errores en los pines de los conectores RGB. Si el pin no funciona, prueba el alternativo (PD1 en lugar de PD0, etc.) o consulta el esquema del repositorio de BTT en GitHub.

virtual_leds — segmentar una tira en zonas lógicas

[virtual_leds] permite dividir una tira física en segmentos independientes y controlar cada zona por separado. Muy útil en configuraciones como el Stealthburner (logo + nozzle en la misma cadena) o cualquier tira que quieras controlar por zonas.

[neopixel toolhead_leds]
pin: nhk:gpio7
chain_count: 3
color_order: GRB
initial_RED: 0.0
initial_GREEN: 0.0
initial_BLUE: 0.0

# Segmento 1: LED del logo (LED nº 1 de la cadena)
[virtual_leds logo_leds]
leds: neopixel:toolhead_leds (1)

# Segmento 2: LEDs del nozzle (LEDs 2 y 3)
[virtual_leds nozzle_leds]
leds: neopixel:toolhead_leds (2, 3)

Ahora puedes usar logo_leds y nozzle_leds de forma independiente en tus efectos y macros, aunque físicamente sean la misma tira.

Comandos SET_LED y SET_LED_TEMPLATE

SET_LED — cambio directo de color

# Cambiar todos los LEDs de la tira
SET_LED LED=mi_tira_led RED=0.5 GREEN=0.0 BLUE=0.0

# Cambiar un LED específico (INDEX empieza en 1)
SET_LED LED=mi_tira_led RED=1.0 GREEN=0.0 BLUE=0.0 INDEX=1

# Apagar todos
SET_LED LED=mi_tira_led RED=0 GREEN=0 BLUE=0

# Actualizar varios LEDs de golpe sin parpadeos intermedios
# TRANSMIT=0 acumula el cambio sin enviarlo; TRANSMIT=1 (el último) envía todo junto
SET_LED LED=mi_tira_led RED=1.0 INDEX=1 TRANSMIT=0
SET_LED LED=mi_tira_led GREEN=1.0 INDEX=2 TRANSMIT=0
SET_LED LED=mi_tira_led BLUE=1.0 INDEX=3 TRANSMIT=1

Parámetro	Descripción
LED	Nombre del [neopixel], [dotstar] o [virtual_leds]
RED, GREEN, BLUE, WHITE	Intensidad del canal (0.0 a 1.0)
INDEX	Número de LED en la cadena (1 = primero). Sin INDEX aplica a todos
TRANSMIT	0 = acumula sin enviar, 1 = envía todo (por defecto 1)
SYNC	0 = no espera a que termine el movimiento anterior

SET_LED_TEMPLATE — plantillas dinámicas

SET_LED_TEMPLATE asigna un template de display a los LEDs, de modo que el color se actualiza automáticamente en tiempo real según el estado de la impresora. Ideal para barras de progreso o indicadores de temperatura.

# Asignar una plantilla al LED
SET_LED_TEMPLATE LED=mi_tira_led TEMPLATE=nombre_template

# Quitar la plantilla y volver a control manual
SET_LED_TEMPLATE LED=mi_tira_led TEMPLATE=""
SET_LED LED=mi_tira_led RED=0 GREEN=0 BLUE=0

Ejemplo de plantilla — barra de progreso de impresión:

[display_template led_progress]
param_led_num: 0
param_led_total: 1
text:
  {% set ratio = printer.display_status.progress %}
  {% set led_ratio = param_led_num|float / param_led_total %}
  {% if ratio > led_ratio %}
    0.0, 0.5, 1.0, 0.0
  {% else %}
    0.0, 0.0, 0.05, 0.0
  {% endif %}

Para aplicarla a cada LED de la tira:

[gcode_macro LEDS_PROGRESS]
gcode:
  {% set leds_count = printer["neopixel mi_tira_led"].chain_count|int %}
  {% for i in range(1, leds_count + 1) %}
    SET_LED_TEMPLATE LED=mi_tira_led TEMPLATE=led_progress param_led_num={i} param_led_total={leds_count} INDEX={i} TRANSMIT={ 1 if i == leds_count else 0 }
  {% endfor %}

Macros para el ciclo de impresión

El set mínimo que vale la pena tener configurado:

# ─── Iluminación básica ─────────────────────────────────────────────────────

[gcode_macro LEDS_OFF]
description: Apagar todos los LEDs
gcode:
    SET_LED LED=mi_tira_led RED=0 GREEN=0 BLUE=0 WHITE=0

[gcode_macro LEDS_ON]
description: Iluminación blanca para cámara
gcode:
    SET_LED LED=mi_tira_led RED=1.0 GREEN=1.0 BLUE=1.0

# ─── Estados de impresión ───────────────────────────────────────────────────

[gcode_macro LEDS_HEATING]
description: Naranja — calentando hotend/cama
gcode:
    SET_LED LED=mi_tira_led RED=1.0 GREEN=0.3 BLUE=0.0

[gcode_macro LEDS_LEVELING]
description: Azul — nivelando/mesh
gcode:
    SET_LED LED=mi_tira_led RED=0.0 GREEN=0.2 BLUE=1.0

[gcode_macro LEDS_PRINTING]
description: Verde suave — imprimiendo
gcode:
    SET_LED LED=mi_tira_led RED=0.0 GREEN=0.8 BLUE=0.2

[gcode_macro LEDS_DONE]
description: Verde brillante — impresión finalizada
gcode:
    SET_LED LED=mi_tira_led RED=0.0 GREEN=1.0 BLUE=0.0

[gcode_macro LEDS_ERROR]
description: Rojo — error o pausa por filamento
gcode:
    SET_LED LED=mi_tira_led RED=1.0 GREEN=0.0 BLUE=0.0

[gcode_macro LEDS_PAUSED]
description: Amarillo — impresión pausada
gcode:
    SET_LED LED=mi_tira_led RED=1.0 GREEN=0.8 BLUE=0.0

Intégralas en PRINT_START y PRINT_END:

[gcode_macro PRINT_START]
gcode:
    LEDS_HEATING
    # ... calentar cama y hotend ...
    LEDS_LEVELING
    # ... home + mesh ...
    LEDS_PRINTING
    # ... purga e inicio de impresión ...

[gcode_macro PRINT_END]
gcode:
    # ... retract, park ...
    LEDS_DONE

Control desde Mainsail y Fluidd

Las tiras [neopixel] y [dotstar] gestionadas directamente por Klipper aparecen automáticamente en el panel web bajo Dashboard → Miscellaneous:

Desde ahí puedes cambiar los colores manualmente con sliders sin necesidad de macros.

Los LEDs controlados por WLED, LUMEN o LED Effects no aparecen en Miscellaneous. Se controlan únicamente a través de macros G-code.

LED Effects — efectos avanzados

klipper-led_effect añade efectos dinámicos a los LEDs gestionados por Klipper: breathing, chasing, progress bar, temperatura en tiempo real, reacción a errores, arco iris, y muchos más. Es lo que usan la mayoría de configuraciones de Voron y similares.

Instalación

cd ~
git clone https://github.com/julianschill/klipper-led_effect.git
cd klipper-led_effect
./install-led_effect.sh

Si tu instalación está en rutas no estándar:

./install-led_effect.sh [-k <klipper path>] [-s <klipper service name>] [-c <config path>]

Añade esto en moonraker.conf para recibir actualizaciones automáticas:

[update_manager led_effect]
type: git_repo
path: ~/klipper-led_effect
origin: https://github.com/julianschill/klipper-led_effect.git
primary_branch: master
is_system_service: False

El repositorio incluye una app de escritorio (Windows y Mac) para simular efectos antes de aplicarlos a la impresora. Descárgala desde Releases → Assets. Ahorra mucho tiempo de prueba y error.

Controlar los efectos

# Activar un efecto
SET_LED_EFFECT EFFECT=nombre_efecto

# Activar con fade-in de 1 segundo
SET_LED_EFFECT EFFECT=nombre_efecto FADETIME=1.0

# Parar un efecto concreto
SET_LED_EFFECT EFFECT=nombre_efecto STOP=1

# Parar todos los efectos activos
STOP_LED_EFFECTS

Estructura de [led_effect]

[led_effect nombre_efecto]
leds:
    neopixel:mi_tira_led              # Toda la tira
    neopixel:mi_tira_led (1-8)        # LEDs 1 a 8
    neopixel:mi_tira_led (9-16)       # LEDs 9 a 16
    virtual_leds:logo_leds            # Segmento virtual
    dotstar:mi_dotstar (1,3,5)        # LEDs específicos
autostart: true                       # Activar al arrancar Klipper
frame_rate: 24                        # Fotogramas/segundo
heater: extruder                      # Vincular a temperatura de un heater
run_on_error: false                   # Solo se activa en estado de error crítico
layers:
    # tipo     vel  ciclos  mezcla  (R,G,B) o (R,G,B,W)
    breathing  10   1       top     (0.5, 0.5, 1.0)

Parámetros de capa:

Parámetro	Descripción
autostart	true activa el efecto al iniciar Klipper
frame_rate	FPS de actualización. 24 es suficiente para casi todo
heater	Vincula el efecto a la temperatura de un heater (extruder, heater_bed)
analog_pin	Vincula el efecto al valor de un pin analógico
stepper	Vincula el efecto al estado de un stepper
run_on_error	Si true, solo activo en estado de error de Klipper

Para la referencia completa de tipos de capa y parámetros: documentación oficial del plugin.

Ejemplos de efectos

Breathing — respiración suave, ideal para idle:

[led_effect leds_idle]
autostart: true
frame_rate: 24
leds:
    neopixel:mi_tira_led
layers:
    breathing  10  1  top  (0.2, 0.2, 0.8)

Temperatura del nozzle en tiempo real — azul frío → rojo caliente:

[led_effect temperatura_nozzle]
leds:
    neopixel:mi_tira_led
autostart: true
frame_rate: 24
heater: extruder
layers:
    heater  50  0  add   (1.0, 0.0, 0.0), (0.0, 0.0, 1.0)

Barra de progreso de impresión:

[led_effect barra_progreso]
leds:
    neopixel:mi_tira_led
autostart: false
frame_rate: 24
layers:
    progress  -1  0  add   (0.0, 0.0, 1.0), (0.0, 0.1, 0.6)
    static     0  0  top   (0.0, 0.0, 0.05)

Arco iris continuo:

[led_effect rainbow]
leds:
    neopixel:mi_tira_led
autostart: false
frame_rate: 24
layers:
    gradient  0.3  1  add  (0.3, 0.0, 0.0),(0.0, 0.3, 0.0),(0.0, 0.0, 0.3)

Error crítico — rojo parpadeante (se activa automáticamente):

[led_effect error_critico]
leds:
    neopixel:mi_tira_led
layers:
    strobe     1  1.5  add         (1.0, 1.0, 1.0)
    breathing  2  0    difference  (0.95, 0.0, 0.0)
    static     1  0    top         (1.0, 0.0, 0.0)
autostart: false
frame_rate: 24
run_on_error: true

Comet / persecución:

[led_effect loading]
leds:
    neopixel:mi_tira_led
autostart: false
frame_rate: 24
layers:
    comet  0.3  0  add  (0.0, 0.0, 1.0)

---

LEDs en el toolhead — Stealthburner y similares

Si tienes un cabezal Voron Stealthburner (o cualquier toolhead con LEDs en el hotend), puedes usar el script de post-procesado de JJR para que los LEDs cambien de color según el tipo de trazada que está imprimiendo: perímetros, relleno, soporte, etc.

La versión actualizada del script está en este repositorio.

Configuración base para Stealthburner

[neopixel sb_leds]
pin: toolhead:gpio7       # Ajusta al pin de tu toolboard
chain_count: 3
color_order: GRB
initial_RED: 0.0
initial_GREEN: 0.0
initial_BLUE: 0.0

[virtual_leds sb_logo]
leds: neopixel:sb_leds (1)

[virtual_leds sb_nozzle]
leds: neopixel:sb_leds (2, 3)

Añadir el script al laminador

PrusaSlicer / SuperSlicer / OrcaSlicer

1. Copia stealthburner_colors.py a tu ordenador (en una ruta sin espacios)

2. Asegúrate de tener Python 3 instalado

3. En el laminador: Print Settings → Output Options → Post-processing scripts — añade la ruta completa al script

Al laminar aparece una ventana de terminal confirmando la ejecución.

Cura

Para verificar que funcionó, abre el G-code generado con un editor y busca SET_LED LED=sb_leds. Deben aparecer cambios de color en los puntos de transición entre tipos de trazada.

---

Opción 2 — Hardware externo o segunda MCU

Cuando la MCU principal no tiene pines libres, quieres controlar tiras grandes con animaciones fluidas a 60fps, o prefieres un sistema de efectos más rico sin escribir código, estas tres opciones cubren todos los casos.

WLED vs LUMEN vs RP2040 — ¿cuándo usar cada uno?

	WLED	LUMEN	RP2040 / Pi Pico
Hardware extra	ESP8266/ESP32 (~5€)	Ninguno (usa la Pi)	Pi Pico (~5€)
Conexión a Klipper	Moonraker ([wled])	Moonraker (plugin)	MCU secundaria ([mcu])
FPS / fluidez	Alta (WiFi, alguna latencia)	60fps GPIO nativo	Igual que MCU principal
Número de efectos	+100 efectos y paletas	12 efectos, 14 estados automáticos	Los de klipper-led_effect
Interfaz de configuración	App web propia + presets	Archivo lumen.cfg	printer.cfg
Detección automática de estados	No — necesita macros	Sí — sin tocar PRINT_START	No — necesita macros
Mejor para	Cerramientos grandes, efectos vistosos	Pi ya instalada, cero hardware extra	Pines MCU agotados, tiras largas

Las tres opciones son compatibles entre sí. Puedes tener WLED para el cerramiento, LUMEN para el toolhead, y una segunda MCU para una tira larga simultáneamente.

---

WLED — firmware ESP8266/ESP32

WLED es un firmware open-source para ESP8266/ESP32 con más de 100 efectos y paletas de color. Se integra con Moonraker para controlar presets desde macros G-code.

WLED es la opción recomendada si quieres efectos visuales llamativos en el cerramiento. La ESP32 cuesta menos de 5€ y aguanta tiras de cientos de LEDs sin problemas.

Configurar presets en WLED

Antes de integrar con Klipper, define los presets en la app de WLED:

1. Elige color y efecto desde la pantalla principal

2. Pestaña Presets → crear nuevo preset. El ID del preset es el número que usarás en Klipper

3. Crea al menos: encendido con efecto, apagado, y uno por cada estado de impresión

Asigna una IP estática a tu WLED desde la configuración WiFi del propio WLED. Si cambia la IP, los macros dejan de funcionar.

moonraker.conf

[wled cerramiento]
type: http
address: 192.168.1.99    # IP estática de tu WLED
initial_red: 0.5
initial_green: 0.4
initial_blue: 0.3
chain_count: 60

# Si tienes varios WLED, añade más secciones
[wled toolhead_wled]
type: http
address: 192.168.1.100
chain_count: 8

Macros Klipper para WLED

[gcode_macro WLED_ON]
description: Encender WLED con preset opcional
gcode:
    {% set strip = params.STRIP | default("cerramiento") | string %}
    {% set preset = params.PRESET | default(1) | int %}
    {action_call_remote_method("set_wled_state",
                               strip=strip,
                               state=True,
                               preset=preset)}

[gcode_macro WLED_OFF]
description: Apagar WLED
gcode:
    {% set strip = params.STRIP | default("cerramiento") | string %}
    {action_call_remote_method("set_wled_state",
                               strip=strip,
                               state=False)}

# Macros de estado usando presets
[gcode_macro WLED_HEATING]
gcode:
    WLED_ON STRIP=cerramiento PRESET=2

[gcode_macro WLED_PRINTING]
gcode:
    WLED_ON STRIP=cerramiento PRESET=3

[gcode_macro WLED_DONE]
gcode:
    WLED_ON STRIP=cerramiento PRESET=4

---

LUMEN — plugin Moonraker para Raspberry Pi

LUMEN es un plugin de Moonraker que controla LEDs directamente desde la Raspberry Pi sin necesidad de hardware externo. Detecta automáticamente 14 estados de la impresora y aplica efectos suaves a 60fps usando el GPIO de la Pi.

LUMEN es la mejor opción si ya tienes la Pi y quieres detección automática de estados sin tocar PRINT_START ni PRINT_END. La instalación es un único script.

Instalación

cd ~
git clone https://github.com/MakesBadDecisions/Lumen_RPI.git lumen
cd lumen
chmod +x install.sh
./install.sh

El instalador detecta las rutas de Klipper/Moonraker automáticamente, instala la librería rpi-ws281x, levanta el servicio ws281x-proxy (necesario para acceso GPIO a 60fps) y añade la configuración base al moonraker.conf.

moonraker.conf

[lumen]
config_path: ~/printer_data/config/lumen.cfg

[update_manager lumen]
type: git_repo
path: ~/lumen
origin: https://github.com/MakesBadDecisions/Lumen_RPI.git
managed_services: moonraker
primary_branch: main

Configuración en lumen.cfg

GPIO (Pi directa)

Para tiras WS2812B conectadas directamente a los GPIO de la Raspberry Pi. Corre a 60fps sin tocar la cola G-code.

[lumen_settings]
gpio_fps: 60               # FPS de animación
bored_timeout: 300         # Segundos idle antes de "bored"
sleep_timeout: 600         # Segundos bored antes de "sleep"

[lumen_group cerramiento]
driver: proxy              # GPIO via ws281x-proxy (recomendado para 60fps)
gpio_pin: 18               # Pin BCM válidos: 12, 13, 18, 19
index_start: 1
index_end: 60
color_order: GRB
group_brightness: 0.8
on_idle: pulse cobalt
on_heating: thermal bed ice lava 2.0
on_printing: progress steel matrix 1.5
on_cooldown: pulse ice
on_error: heartbeat red
on_bored: disco
on_sleep: off

Los únicos GPIO válidos para WS2812B en la Pi son 12, 13, 18 y 19 (pines PWM hardware). GPIO 18 es el más recomendado — GPIO 19 puede dar conflictos con la salida de audio si está habilitada en /boot/config.txt.

MCU (toolhead/EBB)

PWM (tira monocolor)

Estados automáticos de la impresora

LUMEN detecta 14 estados directamente desde Moonraker/Klipper sin necesidad de macros en PRINT_START/PRINT_END:

Estado	Cuándo se activa
idle	Impresora fría, sin objetivos de temperatura
heating	Calentando hotend o cama
printing	Impresión activa a temperatura
cooldown	Impresión terminada, todavía caliente (>40°C)
error	Klipper en shutdown o error
paused	Impresión pausada
cancelled	Impresión cancelada
homing	Ejecutando homing
meshing	Haciendo bed mesh
leveling	Nivelando
probing	Probando con el sensor
filament_change	Cambio de filamento (requiere sensor de runout)
bored	Idle durante N minutos (configurable)
sleep	Bored durante N minutos (configurable)

Efectos disponibles

on_idle: solid white           # Sólido
on_idle: pulse cobalt          # Respiración/fade
on_error: heartbeat red        # Doble pulso (latido)
on_bored: disco                # Destellos arcoíris
on_bored: rainbow              # Arcoíris continuo
on_heating: fire               # Llama simulada
on_printing: comet cobalt      # Cometa con estela
on_cooldown: chase 1           # Persecución predador/presa (multi-grupo)
on_idle: kitt red              # Scanner KITT (Knight Rider)

# Gradiente térmico: thermal <fuente> <color_frío> <color_caliente> <curva>
on_heating: thermal bed ice lava 2.0

# Barra de progreso: progress <color_inicio> <color_fin> <curva>
on_printing: progress steel matrix 1.5

on_sleep: off                  # Apagado

Integración opcional con macros

LUMEN funciona sin macros — los estados se detectan automáticamente. Para control manual añade el archivo de macros de ejemplo a printer.cfg:

[include lumen_macros.cfg]

LUMEN_RELOAD                                       # Recargar config sin reiniciar Moonraker
LUMEN_SET GROUP=cerramiento EFFECT=solid COLOR=white DURATION=10  # Override temporal
LUMEN_TEST STATE=heating                           # Probar un estado

Modo test — verificar efectos sin imprimir

LUMEN_TEST_START                           # Entrar en modo test
LUMEN_TEST_NEXT_STATE                      # Ciclar: idle → heating → printing → ...
LUMEN_TEST_NEXT_EFFECT GROUP=cerramiento   # Ciclar efectos en un grupo
LUMEN_TEST_STOP                            # Salir y recargar config

API REST

curl http://localhost:7125/server/lumen/status | jq                            # Estado + métricas
curl -X POST "http://localhost:7125/server/lumen/set_group?group=cerramiento&effect=solid&color=white"
curl -X POST "http://localhost:7125/server/lumen/reload"                       # Hot reload config
curl -X POST "http://localhost:7125/server/lumen/test_event?event=heating"     # Forzar estado

---

Segunda MCU — RP2040 / Pi Pico

Si tu electrónica no tiene pines libres o quieres controlar tiras de más de 20 LEDs sin saturar la MCU principal, un microcontrolador dedicado con firmware Klipper es la solución más limpia: los LEDs aparecen en Klipper como cualquier otro neopixel y son compatibles con LED Effects.

La opción más recomendada: Raspberry Pi Pico (RP2040)

Cuesta menos de 5€, tiene soporte nativo en Klipper, y puede manejar centenares de LEDs sin esfuerzo. Mucho más potente que un Arduino Nano para este uso.

Compilar firmware para RP2040

cd ~/klipper
make clean
make menuconfig

Configuración en menuconfig:

• Micro-controller Architecture: Raspberry Pi RP2040

• Bootloader offset: No bootloader

• Communication interface: USB

make

Con el Pico en modo BOOTSEL (mantén el botón pulsado al conectar el USB), aparece como unidad de almacenamiento. Copia el archivo .uf2 generado.

Configurar en printer.cfg

[mcu pico_leds]
serial: /dev/serial/by-id/usb-Klipper_rp2040_XXXXX-if00

[neopixel tira_pico]
pin: pico_leds:gpio0      # GPIO del Pico conectado a la tira
chain_count: 60
color_order: GRB
initial_RED: 0.3
initial_GREEN: 0.3
initial_BLUE: 0.3

Una vez configurado puedes usar este [neopixel] con cualquier macro SET_LED o con el plugin LED Effects exactamente igual que si estuviera en la MCU principal.

Arduino Nano como alternativa

Si tienes un Arduino Nano disponible también funciona. En make menuconfig selecciona Atmega AVR → atmega328p. El RP2040 es preferible por capacidad y mejor soporte, pero el Nano funciona perfectamente para tiras pequeñas.

---

Solución de problemas

Los colores salen incorrectos

El problema casi siempre es el color_order. Prueba en este orden:

1. Comprueba el modelo exacto de tu LED (WS2812B, SK6812, APA102...)

2. Consulta la tabla de tipos más arriba y ajusta color_order

3. Si mezclas LEDs de distinto tipo en la misma cadena, puedes especificar uno por LED: color_order: GRB, GRB, GRBW

Los LEDs parpadean o hacen cosas raras

Causa probable: señal

• Falta resistencia en el pin de datos (300-500 Ω)

• Cable de señal demasiado largo (más de 50 cm sin repetidor)

• GND no compartido entre MCU y tira

Causa probable: alimentación

• Tira alimentada desde el 5V de la electrónica con más de 20 LEDs

• Fuente 5V insuficiente — usa la calculadora WLED para verificar amperaje

• Capacitor 1000 µF entre +5V y GND al inicio de la tira estabiliza la tensión

"Neopixel update did not succeed" en el log

Este error aparece cuando el timing de la señal falla. Causas más frecuentes:

• MCU demasiado cargada — reduce frame_rate en LED Effects (de 24 a 10 o menos)

• Tira conectada a pin de Raspberry Pi directamente sin usar LUMEN ni segunda MCU

• Interferencias en el cable de señal — acorta el cable o añade el condensador

Solo se enciende el primer LED

Comprobaciones:

1. Verifica que chain_count coincide con el número real de LEDs

2. El sentido de la tira es incorrecto — invierte la conexión o usa otro punto de entrada

3. Alimentación insuficiente — a partir del LED 15-20 sin alimentación externa la señal se degrada

Los efectos de LED Effects no se activan

1. Confirma que el plugin está instalado: en Mainsail → Sistema → Extensiones, debe aparecer led_effect

2. Reinicia Klipper tras instalar el plugin

3. Verifica que los nombres de [neopixel] en el [led_effect] coinciden exactamente con los definidos en el cfg

4. Si usas virtual_leds, la referencia en [led_effect] debe ser virtual_leds:nombre no neopixel:nombre