Contador de filamentos de impresora 3D inteligente: 5 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:40

¿Por qué molestarse en contar filamentos? Algunas razones:

Las impresiones exitosas requieren un extrusor correctamente calibrado: cuando el gcode le dice al extrusor que mueva el filamento 2 mm, debe moverse exactamente 2 mm. Suceden cosas malas si se sobreextruye o subextruye. Un contador bien calibrado puede hacer que una extrusora sea honesta

Los cortadores aproximan la cantidad total de filamento que tomará una impresión determinada (tanto en longitud como en peso) y me gustaría verificar esos valores

La medición del movimiento del filamento también me permite saber cuándo ha comenzado la impresión y cuándo se ha detenido

Necesitaba algo para cubrir el espacio dejado por la eliminación del feo logo gigante en el frente de mi impresora

Es genial

Me inspiré en este instructivo, que reutilizó un viejo mouse PS / 2 como contador de filamentos para una impresora 3D. No solo agregó una función útil a una impresora 3D, sino que también reutilizó un dispositivo antiguo que de otro modo habría terminado en un vertedero. Pero ese proyecto se construyó alrededor de la interfaz PS / 2 del mouse, que parecía innecesariamente engorrosa. Así que aproveché esto como una oportunidad para aprender sobre el único componente esencial: el codificador rotatorio.

Suministros

codificador rotatorio

Placa de desarrollo basada en ESP32

Pantalla OLED I2C (la unidad de dos colores se ve especialmente bien)

Diminuto pulsador momentáneo

Cojinete 608ZZ desengrasado

Dos juntas tóricas de la ferretería (~ 33 mm de DI x ~ 1,5 mm de diámetro del perfil - ver comentarios)

Dos tornillos autorroscantes de 2,5 mm para la carcasa

Dos tornillos, tuercas y arandelas de 4 mm para fijar el soporte a su impresora

Manojo de alambres

Impresora 3D y algo de filamento

Paso 1: elija un codificador rotatorio

Los codificadores rotatorios traducen el movimiento de rotación en pulsos eléctricos. Todos los ratones de la vieja escuela los usaban para medir el movimiento de la bola rodante, y los ratones ópticos más modernos (ja, ja) todavía los usaban para la rueda de desplazamiento, que es lo que tenía por ahí y usé para la experimentación inicial. Desafortunadamente, el mío no ofrecía puntos de montaje obvios y su resolución era pobre.

Si vale la pena hacerlo, vale la pena exagerar. Así que compré un codificador grande, amigable, de 360 pulsos por revolución y construí mi proyecto en torno a él. El que elegí fue un codificador rotatorio óptico incremental Signswise, tipo LPD3806-360BM-G5-24C. Pero cualquier codificador decente servirá.

Paso 2: agregue una polea y un rodillo

El movimiento lineal del filamento se traduce en un movimiento de rotación del codificador mediante una polea. Y el filamento se sostiene contra la polea mediante una polea tensora.

La polea tiene dos ranuras, cada una sujeta una junta tórica estirada para que no se resbale.

La rueda loca tiene una sola ranura en V para mantener el filamento centrado en la polea del codificador. Se asienta sobre un rodamiento 608ZZ que tenía por ahí, y está montado en un resorte en espiral impreso en el cuerpo principal de mi proyecto. (Archivos STL adjuntos a continuación).

Esto requirió un poco de prueba y error para hacerlo bien, pero mi diseño debería adaptarse a una variedad de ángulos y radios de carrete, permitiendo que el filamento se desenrolle desde cualquier parte del carrete, desde el principio hasta el final de una impresión. Y el resorte impreso facilita la inserción o extracción del filamento al cambiar de carrete.

Paso 3: codificación

Para contar el filamento, cualquier placa de desarrollo con dos entradas digitales servirá. El codificador que elegí tiene cuatro pines: Vcc, tierra y dos pines del codificador. Aquí hay un artículo realmente agradable que explica cómo funcionan los codificadores rotatorios y cómo conectarlos con Arduino. (También: este artículo sobre codificadores de 3 pines).

El conteo básico es simple: dos entradas, configuradas para activarse internamente para que las resistencias externas no necesiten soldarse a Vcc, y una interrupción. También agregué un botón de cero / reinicio, que requiere una entrada más e interrupción:

void setUpPins () {

pinMode (ENCODER_PIN_1, INPUT_PULLUP); pinMode (ENCODER_PIN_2, INPUT_PULLUP); pinMode (ZERO_BTN_PIN, INPUT_PULLUP); attachInterrupt (ENCODER_PIN_1, encoderPinDidChange, CHANGE); attachInterrupt (ZERO_BTN_PIN, zeroButtonPressed, CAMBIAR); } void IRAM_ATTR encoderPinDidChange () {if (digitalRead (ENCODER_PIN_1) == digitalRead (ENCODER_PIN_2)) {posición + = 1; } else {posición - = 1; }} void IRAM_ATTR zeroButtonPressed () {// manejar cero y restablecer}

Pero quería algo más que un contador tonto. Con un ESP32 (o ESP8266) y su WiFi integrado, puedo hacer algo con los datos que estoy recopilando. Usando un código de tiempo de espera simple (que se explica a continuación), puedo determinar cuándo comienza y termina la impresión, y puedo enviar esos eventos como notificaciones a mi teléfono. En el futuro, puedo agregar un sensor de agotamiento y notificarme (y pausar mi impresora) cuando sea necesaria mi atención.

El código completo está en Github.

Algunas notas sobre el código:

Para personalizar esto para su construcción, todo lo que necesita es la resolución (encoderPPR), en pulsos por revolución, que generalmente es el doble de la especificación establecida, y el radio de la polea (wheelRadius). Estos valores, más el ssid y la contraseña de su wifi y los pines específicos conectados al botón, el codificador y la pantalla OLED, van todos en config.h

El botón cero también funciona como reinicio: manténgalo presionado para reiniciar la placa, lo cual es útil para depurar

Las interrupciones son poderosas, a veces demasiado poderosas. Un solo toque del botón cero podría hacer que la función zeroButtonPressed () se llame de 10 a 20 veces, así que agregué algo de lógica antirrebote. Mi codificador óptico no lo necesitaba, pero YMMV

Mientras que las interrupciones se encargan de las entradas de forma asincrónica, la rutina loop () se encarga de la contabilidad. El encoderState, una enumeración que puede alimentarse, retraerse o detenerse, se actualiza con el cambio de posición del codificador. Los tiempos de espera determinan entonces cuándo la impresora ha comenzado y concluido la impresión. Pero la parte complicada es que las impresoras 3D con frecuencia inician y detienen el movimiento, por lo que lo que funcionó mejor fue definir el evento de "impresión completa" que permanece detenida continuamente durante al menos 5 segundos. Cualquier movimiento activa un segundo temporizador que define el evento de "impresión iniciada" solo si no ocurre ningún evento de "impresión completa" en un período de tiempo de 15 segundos. En la práctica, esto funciona a la perfección

Para que el código del bucle principal () se pueda ejecutar sin trabas, el código antirrebote se ejecuta en un bucle de tareas RTOS. Del mismo modo, las solicitudes http para enviar notificaciones son sincrónicas y, por lo tanto, están en segundo plano. Por lo tanto, las animaciones se ejecutan sin problemas y el conteo nunca se detiene

Hay un montón de código adicional en mi ejemplo para (A) establecer y mantener una conexión de red con WiFi y mDNS, (B) obtener la hora de un servidor NTC para poder marcar la hora en mis notificaciones de inicio y finalización y mostrar un reloj alegre en mi OLED y (C) manejan las actualizaciones de OTA para que no tenga que conectar físicamente mi placa a mi Mac para obtener actualizaciones de código. Por el momento, todo está en un archivo C ++ monolítico, solo porque no me he tomado el tiempo para organizarlo mejor

Utilicé la maravillosa (y gratuita) aplicación Prowl iOS para enviar notificaciones automáticas a mi teléfono con nada más que métodos HTTP Get

Para desarrollar el código y flashear la placa, utilicé el espectacular PlatformIO que se ejecuta en Visual Studio Code, ambos gratuitos

Para mi proyecto, utilicé estas bibliotecas: u8g2 de Oliver, elapsedMillis de Paul Stoffregen y HTTPClient de Markus Sattler, que viene con la plataforma Espressif ESP32. Todo lo demás viene con la biblioteca Arduino o la plataforma ESP32 en PlatformIO

Finalmente, creé seis mapas de bits simples de mi polea principal en diferentes ángulos, para poder mostrar una pequeña animación de rueda giratoria en el OLED detrás del mostrador. Se mueve en la dirección apropiada con el codificador, aunque mucho más rápido para un efecto más dramático

Paso 4: cableado

Diseñé esto para que el cableado fuera completamente simple, principalmente para que mi gabinete pudiera ser pequeño, pero también para que la depuración fuera directa. Tenga en cuenta las condiciones de hacinamiento en mi pequeña caja.:)

El primer requisito fue la tensión de alimentación de 5 V de mi codificador rotatorio. De las diversas placas de desarrollo ESP32 que tenía en mi escondite, solo unas pocas suministraban 5V verdaderos en el pin Vcc cuando se alimentaban con USB. (Los otros midieron 4.5-4.8V, que, en caso de que sus matemáticas sean malas, es inferior a 5V). La placa que usé fue una Wemos Lolin32.

A continuación, vienen los dos pines de señal del codificador rotatorio. Como estoy usando interrupciones, la principal preocupación es que los pines que uso no interfieran con nada. Los documentos ESP32 indican que ADC2 no se puede usar al mismo tiempo que WiFi, por lo que desafortunadamente significa que no puedo usar ninguno de los pines GPIO de ADC2: 0, 2, 4, 12, 13, 14, 15, 25, 26 o 27. Elegí 16 y 17.

Consejo profesional: si, después de juntar todo esto, su codificador parece estar contando hacia atrás, puede simplemente intercambiar las dos asignaciones de pines en config.h.

Finalmente, conecte el cable de tierra del codificador rotatorio a… redoble de tambor… la clavija de tierra.

A continuación, el botón de puesta a cero / reinicio se conecta entre tierra y otro pin libre (elegí GPIO 18).

El botón que usé fue un pequeño interruptor momentáneo que rescaté del mouse de computadora mencionado anteriormente, pero cualquier botón que tenga por ahí servirá. Puedes verlo descansando en un pequeño soporte que hice justo sobre el tablero.

Finalmente, el OLED, si aún no está conectado a su placa, solo necesita cuatro pines: 3V3, tierra, reloj i2c y datos i2c. En mi tablero de desarrollo, el reloj y los datos son 22 y 21, respectivamente.

Paso 5: Imprima las piezas

Diseñé siete partes para esta construcción:

La polea, que se monta directamente en el eje del codificador rotatorio

La polea tensora, que encaja sobre un cojinete 608ZZ (retire las cubiertas y desengrase con WD40 para que gire libremente)

El soporte, en el que se montan las dos ruedas y el codificador: observe el resorte en espiral para la rueda guía

Un soporte para estabilizar el soporte. La foto de este paso muestra cómo se fija el soporte al soporte

El gabinete (inferior) para sostener mi placa de desarrollo ESP32, con un espacio para el cable USB en el costado y otro en la parte superior para el conector que agregué a los cables del codificador. Este está diseñado para adaptarse al Wemos Lolin32, por lo que es posible que deba modificar un poco este diseño para que se ajuste a una placa diferente

El gabinete (arriba) para sostener la pantalla OLED, otra espiral para el botón de cero / reinicio

Un soporte para botones personalizado para el pequeño interruptor que tenía, diseñado para descansar entre los dos estantes dentro del gabinete inferior. Usé un soldador para "pegar" el interruptor al soporte; consulte el paso anterior para ver una foto

Todo está diseñado para imprimirse sin soportes. Todo lo que necesita es PLA normal en el color de su elección.

Júntelo todo, conéctelo a su impresora (es posible que se requiera algo de creatividad aquí) y listo.