Contador de filamento de impressora 3D inteligente: 5 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Por que se preocupar em contar filamentos? Alguns motivos:

Impressões bem-sucedidas requerem uma extrusora devidamente calibrada: quando o gcode diz à extrusora para mover o filamento 2 mm, ela precisa se mover exatamente 2 mm. Coisas ruins acontecem se extrusão excessiva ou insuficiente. Um contador bem calibrado pode manter uma extrusora honesta

Os Slicers aproximam a quantidade total de filamento que uma impressão terá (em comprimento e peso) e eu gostaria de verificar esses valores

Medir o movimento do filamento também me permite saber quando a impressão começou e quando parou

Eu precisava de algo para cobrir o espaço deixado pela remoção do logotipo gigante feio na frente da minha impressora

É legal

Fui inspirado por este instrutível, que reaproveitou um mouse PS / 2 antigo como contador de filamentos para uma impressora 3D. Além de adicionar um recurso útil a uma impressora 3D, ele reaproveitou um dispositivo antigo que, de outra forma, teria acabado em um aterro sanitário. Mas esse projeto foi construído em torno da interface PS / 2 do mouse, que parecia desnecessariamente complicada. Portanto, aproveitei a oportunidade para aprender sobre o único componente essencial: o codificador rotativo.

Suprimentos

Codificador rotativo

Placa dev baseada em ESP32

Tela I2C OLED (unidade de duas cores parece especialmente legal)

Botão de pressão momentâneo minúsculo

Rolamento 608ZZ sem graxa

Dois anéis de vedação da loja de ferragens (~ 33 mm ID x ~ 1,5 mm de diâmetro do perfil - ver comentários)

Dois parafusos auto-roscantes de 2,5 mm para o gabinete

Dois parafusos de 4 mm, porcas e arruelas para fixar o suporte à sua impressora

Monte de fios

Impressora 3D e alguns filamentos

Etapa 1: Escolha um codificador rotativo

Codificadores rotativos traduzem o movimento rotacional em pulsos elétricos. Todos os ratos da velha escola os usavam para medir o movimento da bola que rola, e os ratos ópticos mais modernos (ha ha) ainda os usavam para a roda de rolagem, que era o que eu tinha e usei para a experiência inicial. Infelizmente, o meu não ofereceu nenhum ponto de montagem óbvio e sua resolução era ruim.

Se vale a pena fazer, vale a pena exagerar. Então comprei um codificador grande e amigável de 360 pulsos por revolução e construí meu projeto em torno dele. O que escolhi foi um codificador óptico rotativo incremental Signswise, tipo LPD3806-360BM-G5-24C. Mas qualquer codificador decente serve.

Etapa 2: adicionar uma polia e polia

O movimento linear do filamento é traduzido em movimento de rotação do codificador por uma polia. E o filamento é segurado contra a polia por uma polia.

A polia tem duas ranhuras, cada uma segurando um anel de vedação esticado para que não haja deslizamento, A polia tem uma única ranhura em V para manter o filamento centralizado na polia do codificador. Ele fica em um rolamento 608ZZ que eu tinha ao redor e está montado em uma mola espiral impressa bem no corpo principal do meu projeto. (Arquivos STL anexados abaixo.)

Isso exigiu algumas tentativas e erros para acertar, mas meu projeto deve acomodar uma variedade de ângulos e raios do carretel, permitindo que o filamento se desenrole de qualquer parte do carretel, do início ao fim de uma impressão. E a mola impressa facilita a entrada ou saída do filamento ao trocar as bobinas.

Etapa 3: codificação

Para contar apenas o filamento, qualquer placa de desenvolvimento com duas entradas digitais serve. O codificador que escolhi tem quatro pinos: Vcc, terra e dois pinos do codificador. Aqui está um artigo muito bom que explica como os codificadores rotativos funcionam e como fazer a interface com o Arduino. (Além disso: este artigo sobre codificadores de 3 pinos.)

A contagem básica é simples: duas entradas - configuradas para puxar internamente para que os resistores externos não precisem ser soldados ao Vcc - e uma interrupção. Também adicionei um botão zerar / redefinir, exigindo mais uma entrada e interrupção:

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, CHANGE); } void IRAM_ATTR encoderPinDidChange () {if (digitalRead (ENCODER_PIN_1) == digitalRead (ENCODER_PIN_2)) {position + = 1; } mais {posição - = 1; }} void IRAM_ATTR zeroButtonPressed () {// manipular zero e redefinir}

Mas eu queria mais do que apenas um contador idiota. Com um ESP32 (ou ESP8266) e seu WiFi integrado, posso realmente fazer algo com os dados que estou coletando. Usando um código de tempo limite simples (explicado abaixo), posso determinar quando a impressão começa e termina e enviar esses eventos como notificações para o meu telefone. No futuro, posso adicionar um sensor de esgotamento e me notificar (e pausar minha impressora) quando minha atenção for necessária.

O código completo está no Github.

Algumas notas sobre o código:

Para personalizar isso para sua construção, tudo que você precisa é a resolução (encoderPPR) - em pulsos por revolução, que normalmente é o dobro da especificação declarada - e o raio da polia (wheelRadius). Esses valores, mais o ssid e a senha de seu wi-fi e os pinos específicos conectados ao botão, codificador e tela OLED, vão todos no config.h

O botão zero também funciona como um reset - mantenha-o pressionado para reinicializar a placa, o que é útil para depuração

As interrupções são poderosas - às vezes muito poderosas. Um único toque no botão zero pode fazer com que a função zeroButtonPressed () seja chamada de 10 a 20 vezes, então adicionei alguma lógica de debounce. Meu codificador óptico não precisava disso, mas YMMV

Enquanto as interrupções cuidam das entradas de forma assíncrona, a rotina loop () trata da contabilidade. O encoderState - um enum que pode ser alimentado, retraído ou interrompido - é atualizado com a mudança na posição do codificador. Os tempos limite determinam quando a impressora iniciou e concluiu a impressão. Mas a parte complicada é que as impressoras 3D freqüentemente iniciam e param o movimento, então o que funcionou melhor foi definir o evento "impressão concluída" permanecendo continuamente interrompido por pelo menos 5 segundos. Qualquer movimento aciona um segundo temporizador que define o evento de "impressão iniciada" apenas se nenhum evento de "impressão concluída" ocorrer em um período de 15 segundos. Na prática, isso funciona perfeitamente

Assim, o código loop () principal pode ser executado sem restrições, o código debounce é executado em um loop de tarefa RTOS. Da mesma forma, as solicitações de http para enviar notificações são síncronas e, portanto, em segundo plano. Assim, as animações funcionam suavemente e a contagem nunca para

Há um monte de código adicional em meu exemplo para (A) estabelecer e manter uma conexão de rede com WiFi e mDNS, (B) buscar a hora em um servidor NTC para que eu pudesse marcar a hora em minhas notificações de início e término e exibir um relógio animado no meu OLED, e (C) lida com atualizações OTA para que eu não precise conectar fisicamente minha placa ao meu Mac para atualizações de código. No momento, está tudo em um arquivo C ++ monolítico, só porque não reservei tempo para organizá-lo melhor

Usei o maravilhoso (e gratuito) aplicativo Prowl iOS para enviar notificações push para o meu telefone com nada mais do que métodos HTTP Get

Para desenvolver o código e atualizar a placa, usei o espetacular PlatformIO rodando no Visual Studio Code, ambos gratuitos

Para o meu projeto, usei as seguintes bibliotecas: u8g2 de Oliver, elapsedMillis de Paul Stoffregen e HTTPClient de Markus Sattler, que vem com a plataforma Espressif ESP32. Todo o resto vem com a biblioteca Arduino ou a plataforma ESP32 no PlatformIO

Por fim, criei seis bitmaps simples de minha polia principal em ângulos diferentes, para que pudesse mostrar uma pequena animação de roda giratória no OLED atrás do balcão. Ele se move na direção apropriada com o codificador, embora muito mais rápido para um efeito mais dramático

Etapa 4: Fiação

Eu projetei isso para que a fiação fosse extremamente simples, principalmente para que meu gabinete pudesse ser pequeno, mas também para que a depuração fosse direta. Observe as condições apertadas em minha caixinha.:)

O primeiro requisito foi a tensão de alimentação de 5 V do meu codificador rotativo. Das várias placas dev ESP32 que eu tinha em meu estoque, apenas algumas forneceram 5V verdadeiros no pino Vcc quando alimentado por USB. (As outras mediam 4,5-4,8V, que, caso sua matemática seja ruim, é inferior a 5V.) A prancha que usei foi uma Wemos Lolin32.

Em seguida, vêm os dois pinos de sinal do codificador rotativo. Como estou usando interrupções, a principal preocupação é que os pinos que uso não interfiram em nada. Os documentos ESP32 afirmam que ADC2 não pode ser usado ao mesmo tempo que WiFi, o que, infelizmente, significa que não posso usar nenhum dos pinos GPIO ADC2: 0, 2, 4, 12, 13, 14, 15, 25, 26 ou 27. Escolhi 16 e 17.

Dica profissional: se, depois de colocar tudo isso junto, seu codificador parece estar contando regressivamente, você pode simplesmente trocar as atribuições de dois pinos em config.h.

Finalmente, conecte o fio de aterramento do codificador rotativo ao … rolo de cilindro … ao pino de aterramento.

Em seguida, o botão de zerar / redefinir é conectado entre o aterramento e outro pino livre (eu escolhi GPIO 18).

O botão que usei foi um pequeno interruptor momentâneo que resgatei do mouse de computador mencionado acima, mas qualquer botão que você tiver servirá. Você pode vê-lo descansando em um pequeno suporte que fiz para ele bem sobre a placa.

Finalmente, o OLED, se ainda não estiver conectado à sua placa, precisa de apenas quatro pinos: 3V3, terra, relógio i2c e dados i2c. Na minha placa de desenvolvimento, o relógio e os dados são 22 e 21, respectivamente.

Etapa 5: Imprima as peças

Projetei sete peças para esta construção:

A polia, que é montada diretamente no eixo do codificador rotativo

A polia, que se encaixa sobre um rolamento 608ZZ (remova as proteções e desengraxe com WD40 para que gire livremente)

O suporte, no qual as duas rodas e o codificador são montados - observe a mola em espiral para o rolete

Um suporte para estabilizar o suporte. A foto nesta etapa mostra como o suporte se conecta ao suporte

O gabinete (inferior) para acomodar minha placa de desenvolvimento ESP32, com um espaço para o cabo USB na lateral e outro na parte superior para o conector que adicionei aos fios do codificador. Este é projetado para caber no Wemos Lolin32, então você pode ter que modificar este projeto um pouco para caber em uma placa diferente

O gabinete (superior) para segurar a tela OLED, outra espiral para o botão de zerar / redefinir

Um suporte de botão personalizado para o minúsculo interruptor que eu tinha, projetado para ficar entre as duas prateleiras dentro do gabinete inferior. Usei um ferro de solda para "colar" a chave no suporte; veja a etapa anterior para uma foto

Tudo foi projetado para ser impresso sem suportes. PLA normal na cor de sua escolha é tudo que você precisa.

Reúna tudo, conecte à sua impressora (um pouco de criatividade pode ser necessária aqui) e você está pronto para ir.