Contatore di filamenti per stampante 3D intelligente: 5 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:00

Perché preoccuparsi di contare i filamenti? Alcuni motivi:

Le stampe di successo richiedono un estrusore adeguatamente calibrato: quando il gcode dice all'estrusore di spostare il filamento di 2 mm, deve spostarsi esattamente di 2 mm. Le cose brutte accadono se estrude in eccesso o in difetto. Un contatore ben calibrato può mantenere onesto un estrusore

Le affettatrici approssimano la quantità totale di filamento che richiederà una determinata stampa (sia in lunghezza che in peso) e vorrei controllare quei valori

Misurando il movimento del filamento mi fa anche sapere quando è iniziata la stampa e quando si è fermata

Avevo bisogno di qualcosa per coprire lo spazio lasciato dalla rimozione del brutto logo gigante sulla parte anteriore della mia stampante

È bello

Sono stato ispirato da questo istruibile, che ha riproposto un vecchio mouse PS/2 come contatore di filamenti per una stampante 3D. Non solo ha aggiunto una funzionalità utile a una stampante 3D, ma ha riproposto un vecchio dispositivo che altrimenti sarebbe finito in una discarica. Ma quel progetto era costruito attorno all'interfaccia PS/2 del mouse, che sembrava inutilmente ingombrante. Quindi ho colto questa opportunità per conoscere l'unico componente essenziale: l'encoder rotativo.

Forniture

Encoder rotativo

Scheda di sviluppo basata su ESP32

Display I2C OLED (l'unità a due colori sembra particolarmente bella)

Piccolo pulsante momentaneo

Cuscinetto 608ZZ sgrassato

Due o-ring dal negozio di ferramenta (~33 mm ID x ~1,5 mm di diametro del profilo - vedi commenti)

Due viti autofilettanti da 2,5 mm per la custodia

Due viti, dadi e rondelle da 4 mm per fissare il supporto alla stampante

Mazzo di fili

Stampante 3D e alcuni filamenti

Passaggio 1: scegli un encoder rotativo

Gli encoder rotativi traducono il movimento rotatorio in impulsi elettrici. Tutti i mouse della vecchia scuola li usavano per misurare il movimento della pallina rotante, e i mouse ottici più moderni (ah ah) li usavano ancora per la rotella di scorrimento, che è quello che avevo in giro e che usavo per la sperimentazione iniziale. Sfortunatamente, il mio non offriva punti di montaggio evidenti e la sua risoluzione era scarsa.

Se vale la pena farlo, vale la pena esagerare. Così ho comprato un codificatore grande, amichevole, a 360 impulsi per giro e ho costruito il mio progetto attorno ad esso. Quello che ho scelto era un encoder rotativo ottico incrementale Signswise, tipo LPD3806-360BM-G5-24C. Ma qualsiasi codificatore decente andrà bene.

Passaggio 2: aggiungere una puleggia e un tenditore

Il movimento lineare del filamento viene tradotto in movimento rotatorio dell'encoder da una puleggia. E il filamento è tenuto contro la puleggia da un tendicinghia.

La puleggia ha due scanalature, ciascuna contenente un o-ring allungato in modo che non scivoli, Il tenditore ha una singola scanalatura a V per mantenere il filamento centrato sulla puleggia dell'encoder. Si trova su un cuscinetto 608ZZ che avevo in giro, ed è montato su una molla a spirale stampata proprio nel corpo principale del mio progetto. (File STL allegati di seguito.)

Ci sono voluti alcuni tentativi ed errori per essere corretto, ma il mio progetto dovrebbe adattarsi a una varietà di angoli e raggi della bobina, consentendo al filamento di svolgersi da qualsiasi parte della bobina, dall'inizio alla fine di una stampa. E la molla stampata facilita l'inserimento o l'estrazione del filamento quando si cambiano le bobine.

Passaggio 3: codifica

Per contare solo il filamento, andrà bene qualsiasi scheda di sviluppo con due ingressi digitali. L'encoder che ho scelto ha quattro pin: Vcc, terra e due pin dell'encoder. Ecco un articolo davvero carino che spiega come funzionano gli encoder rotativi e come interfacciarli con Arduino. (Anche: questo articolo sugli encoder a 3 pin.)

Il conteggio di base è semplice: due ingressi - impostati per richiamare internamente in modo che i resistori esterni non debbano essere saldati a Vcc - e un interrupt. Ho anche aggiunto un pulsante zero/reset, che richiede un altro input e interrupt:

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; } else { posizione -= 1; } } void IRAM_ATTR zeroButtonPressed() { // gestisce lo zero e ripristina }

Ma volevo più di un semplice contatore stupido. Con un ESP32 (o ESP8266) e il suo WiFi integrato, posso effettivamente fare qualcosa con i dati che sto raccogliendo. Utilizzando un semplice codice di timeout (spiegato di seguito), posso determinare l'inizio e la fine della stampa e inviare tali eventi come notifiche al mio telefono. In futuro, potrei aggiungere un sensore di esaurimento e avvisare me stesso (e mettere in pausa la mia stampante) quando è necessaria la mia attenzione.

Il codice completo è su Github.

Alcune note sul codice:

Per personalizzare questo per la tua build, tutto ciò di cui hai bisogno è la risoluzione (encoderPPR) - in impulsi per giro, che è in genere il doppio delle specifiche dichiarate - e il raggio della puleggia (wheelRadius). Questi valori, più l'ssid e la password del tuo wifi e i pin specifici collegati al pulsante, all'encoder e allo schermo OLED, vanno tutti in config.h

Il pulsante zero funge anche da reset: tienilo premuto per riavviare la scheda, utile per il debug

Gli interrupt sono potenti, a volte troppo potenti. Un singolo tocco del pulsante zero potrebbe causare la chiamata della funzione zeroButtonPressed() 10-20 volte, quindi ho aggiunto una logica di antirimbalzo. Il mio codificatore ottico non ne aveva bisogno, ma YMMV

Mentre gli interrupt si occupano degli input in modo asincrono, la routine loop() gestisce la contabilità. L'encoderState, un'enumerazione che può essere alimentata, retratta o arrestata, viene aggiornata con il cambiamento di posizione dell'encoder. I timeout determinano quindi quando la stampante ha iniziato e concluso la stampa. Ma la parte difficile è che le stampanti 3D spesso avviano e interrompono il movimento, quindi ciò che ha funzionato meglio è stato definire l'evento "stampa completata" rimanendo continuamente fermo per almeno 5 secondi. Qualsiasi movimento attiva un secondo timer che definisce l'evento "stampa avviata" solo se non si verifica alcun evento "stampa completata" in un intervallo di tempo di 15 secondi. In pratica, funziona a meraviglia

Quindi il codice loop() principale può essere eseguito senza vincoli, il codice antirimbalzo viene eseguito in un ciclo di attività RTOS. Allo stesso modo, le richieste http per inviare notifiche sono sincrone e quindi in background. Quindi le animazioni funzionano senza intoppi e il conteggio non si ferma mai

C'è un sacco di codice aggiuntivo nel mio esempio per (A) stabilire e mantenere una connessione di rete con WiFi e mDNS, (B) recuperare l'ora da un server NTC in modo da poter marcare l'ora delle mie notifiche di inizio e fine e visualizzare un orologio sbarazzino sul mio OLED e (C) gestire gli aggiornamenti OTA in modo da non dover connettere fisicamente la mia scheda al mio Mac per gli aggiornamenti del codice. Al momento, è tutto in un file C++ monolitico, solo perché non ho avuto il tempo di organizzarlo meglio

Ho usato la meravigliosa (e gratuita) app Prowl iOS per inviare notifiche push al mio telefono con nient'altro che metodi HTTP Get

Per sviluppare il codice e flashare la scheda, ho utilizzato lo spettacolare PlatformIO in esecuzione su Visual Studio Code, entrambi gratuiti

Per il mio progetto, ho usato queste librerie: u8g2 di Oliver, elapsedMillis di Paul Stoffregen e HTTPClient di Markus Sattler, che viene fornito con la piattaforma Espressif ESP32. Tutto il resto viene fornito con la libreria Arduino o la piattaforma ESP32 in PlatformIO

Infine, ho creato sei semplici bitmap della mia puleggia principale con diverse angolazioni, in modo da poter mostrare una piccola animazione della ruota che gira sull'OLED dietro il bancone. Si muove nella direzione appropriata con l'encoder, anche se molto più veloce per un effetto più drammatico

Passaggio 4: cablaggio

L'ho progettato in modo che il cablaggio fosse semplicissimo, soprattutto in modo che il mio recinto potesse essere piccolo, ma anche in modo che il debug fosse semplice. Nota le condizioni anguste nella mia piccola scatola.:)

Il primo requisito era la tensione di alimentazione di 5V del mio encoder rotativo. Delle varie schede di sviluppo ESP32 che avevo nella mia scorta, solo alcune fornivano veri 5V al pin Vcc quando alimentate da USB. (Le altre hanno misurato 4,5-4,8 V, che, nel caso in cui i tuoi calcoli siano errati, è inferiore a 5 V.) La scheda che ho usato era una Wemos Lolin32.

Successivamente, vengono i due pin del segnale dell'encoder rotativo. Poiché utilizzo gli interrupt, la preoccupazione principale è che i pin che utilizzo non interferiscano con nulla. I documenti ESP32 affermano che ADC2 non può essere utilizzato contemporaneamente al WiFi, quindi sfortunatamente significa che non posso utilizzare nessuno dei pin GPIO ADC2: 0, 2, 4, 12, 13, 14, 15, 25, 26 o 27. Ho scelto 16 e 17.

Suggerimento per professionisti: se, dopo aver messo insieme tutto questo, il tuo codificatore sembra contare all'indietro, puoi semplicemente scambiare le due assegnazioni dei pin in config.h.

Infine, collegare il filo di terra dell'encoder rotativo a… rullo di tamburi… al pin di terra.

Successivamente, il pulsante zero/reset viene collegato tra la massa e un altro pin libero (ho scelto GPIO 18).

Il pulsante che ho usato era un piccolo interruttore momentaneo che ho salvato dal suddetto mouse del computer, ma qualsiasi pulsante che hai in giro andrà bene. Puoi vederlo appoggiato su un piccolo supporto che ho realizzato proprio sopra il tabellone.

Infine, l'OLED, se non è già collegato alla tua scheda, ha bisogno solo di quattro pin: 3V3, terra, clock i2c e dati i2c. Sulla mia scheda di sviluppo, l'orologio e i dati sono rispettivamente 22 e 21.

Passaggio 5: stampare le parti

Ho progettato sette parti per questa build:

La puleggia, che si monta direttamente sull'albero dell'encoder rotativo

L'ingranaggio, che si inserisce su un cuscinetto 608ZZ (rimuovere le protezioni e sgrassare con WD40 in modo che ruoti liberamente)

Il supporto, su cui si montano le due ruote e l'encoder, si nota la molla a spirale per l'ingranaggio

Una staffa per stabilizzare il supporto. La foto in questo passaggio mostra come la staffa si attacca al supporto

L'involucro (in basso) per contenere la mia scheda di sviluppo ESP32, con uno spazio per il cavo USB sul lato e un altro in alto per il connettore che ho aggiunto ai cavi dell'encoder. Questo è progettato per adattarsi a Wemos Lolin32, quindi potresti dover modificare un po' questo design per adattarlo a una scheda diversa

La custodia (in alto) per contenere lo schermo OLED, un'altra spirale per il pulsante zero/reset

Un portabottoni personalizzato per il minuscolo interruttore che avevo, progettato per riposare tra i due ripiani all'interno dell'involucro inferiore. Ho usato un saldatore per "incollare" l'interruttore al supporto; vedere il passaggio precedente per una foto

Tutto è pensato per essere stampato senza supporti. Il PLA normale nel colore che preferisci è tutto ciò di cui hai bisogno.

Metti tutto insieme, collegalo alla tua stampante (qui potrebbe essere necessaria una certa creatività) e sei a posto.