Slimme 3D-printergloeidraadteller - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

Waarom zou je filament tellen? Een paar redenen:

Succesvolle prints vereisen een goed gekalibreerde extruder: wanneer de gcode de extruder vertelt om het filament 2 mm te verplaatsen, moet deze precies 2 mm bewegen. Er gebeuren slechte dingen als het te veel of te weinig extrudeert. Een goed gekalibreerde teller kan een extruder eerlijk houden

Slicers schatten de totale hoeveelheid filament die een bepaalde afdruk nodig heeft (zowel in lengte als in gewicht) en ik zou die waarden graag willen controleren

Door de beweging van filament te meten, weet ik ook wanneer het afdrukken is begonnen en wanneer het is gestopt

Ik had iets nodig om de ruimte te bedekken die was overgebleven door het verwijderen van het lelijke gigantische logo op de voorkant van mijn printer

Het is cool

Ik werd geïnspireerd door deze instructable, die een oude PS/2-muis gebruikte als een filamentteller voor een 3D-printer. Het voegde niet alleen een handige functie toe aan een 3D-printer, het heeft ook een oud apparaat hergebruikt dat anders op een stortplaats zou zijn beland. Maar dat project was gebouwd rond de PS/2-interface van de muis, wat onnodig omslachtig leek. Dus ik greep dit als een kans om meer te weten te komen over het enige essentiële onderdeel: de roterende encoder.

Benodigdheden

Roterende encoder

Op ESP32 gebaseerd ontwikkelbord

I2C OLED-display (tweekleureneenheid ziet er bijzonder cool uit)

Kleine kortstondige drukknop

Ontvet 608ZZ lager

Twee o-ringen van de ijzerhandel (~ 33 mm ID x ~ 1,5 mm profieldiameter - zie opmerkingen)

Twee 2,5 mm zelftappende schroeven voor de behuizing

Twee schroeven, moeren en ringen van 4 mm om de houder aan uw printer te bevestigen

Stelletje draden

3D-printer en wat filament

Stap 1: Kies een roterende encoder

Roterende encoders vertalen rotatiebewegingen in elektrische pulsen. Alle old-school muizen gebruikten ze om de beweging van de rollende bal te meten, en modernere (ha ha) optische muizen gebruikten ze nog steeds voor het scrollwiel, wat ik had liggen en gebruikten voor de eerste experimenten. Helaas bood de mijne geen duidelijke bevestigingspunten en was de resolutie slecht.

Als het de moeite waard is om te doen, is het de moeite waard om te overdrijven. Dus kocht ik een grote, vriendelijke encoder met 360 puls per omwenteling en bouwde mijn project eromheen. Degene die ik koos was een Signswise Incremental Optical Rotary Encoder, type LPD3806-360BM-G5-24C. Maar elke fatsoenlijke encoder zal het doen.

Stap 2: Voeg een katrol en spanrol toe

De lineaire beweging van het filament wordt door een katrol vertaald in een roterende beweging van de encoder. En het filament wordt door een spanrol tegen de poelie gehouden.

De poelie heeft twee groeven, elk met een uitgerekte o-ring zodat er geen wegglijdt is.

De spanrol heeft een enkele v-groef om het filament gecentreerd op de encoderpoelie te houden. Het zit op een 608ZZ-lager dat ik had liggen, en dat is gemonteerd op een spiraalveer die midden in het hoofdgedeelte van mijn project is gedrukt. (STL-bestanden hieronder bijgevoegd.)

Dit kostte wat vallen en opstaan om het goed te krijgen, maar mijn ontwerp moet geschikt zijn voor verschillende hoeken en spoelradii, zodat het filament van elk deel van de spoel kan afwikkelen, helemaal van het begin tot het einde van een afdruk. En de bedrukte veer maakt het gemakkelijk om het filament in of uit te klappen bij het verwisselen van spoelen.

Stap 3: Coderen

Voor het tellen van filament is elk ontwikkelbord met twee digitale ingangen voldoende. De encoder die ik heb gekozen heeft vier pinnen: Vcc, aarde en twee encoderpinnen. Hier is een heel mooi artikel waarin wordt uitgelegd hoe roterende encoders werken en hoe ze met Arduino kunnen worden gekoppeld. (Ook: dit artikel over 3-pins encoders.)

De basistelling is eenvoudig: twee ingangen - ingesteld om intern omhoog te trekken, zodat externe weerstanden niet aan Vcc hoeven te worden gesoldeerd - en één interrupt. Ik heb ook een nul / reset-knop toegevoegd, waarvoor nog een invoer en onderbreking nodig is:

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)) {positie += 1; } anders { positie -= 1; } } void IRAM_ATTR zeroButtonPressed () { // omgaan met nul & reset }

Maar ik wilde meer dan alleen een domme toonbank. Met een ESP32 (of ESP8266) en de ingebouwde wifi kan ik echt iets doen met de gegevens die ik verzamel. Met behulp van een eenvoudige time-outcode (hieronder uitgelegd), kan ik bepalen wanneer het afdrukken begint en eindigt, en die gebeurtenissen als meldingen naar mijn telefoon sturen. In de toekomst kan ik een uitloopsensor toevoegen en mezelf waarschuwen (en mijn printer pauzeren) wanneer mijn aandacht nodig is.

De volledige code staat op Github.

Een paar opmerkingen over de code:

Om dit aan uw build aan te passen, hebt u alleen de resolutie (encoderPPR) nodig - in pulsen per omwenteling, wat meestal twee keer de opgegeven specificatie is - en de straal van de katrol (wheelRadius). Deze waarden, plus de ssid en het wachtwoord van je wifi en de specifieke pinnen die zijn verbonden met de knop, encoder en OLED-scherm, gaan allemaal in config.h

De nulknop doet ook dienst als reset - houd deze ingedrukt om het bord opnieuw op te starten, wat handig is voor foutopsporing

Interrupts zijn krachtig - soms te krachtig. Een enkele tik op de nulknop kan ervoor zorgen dat de functie zeroButtonPressed() 10-20 keer wordt aangeroepen, dus ik heb wat debounce-logica toegevoegd. Mijn optische encoder had het niet nodig, maar YMMV

Terwijl de interrupts de invoer asynchroon afhandelen, handelt de routine loop() de boekhouding af. De encoderState - een opsomming die kan worden ingevoerd, teruggetrokken of gestopt - wordt bijgewerkt met de verandering in positie van de encoder. Time-outs bepalen vervolgens wanneer de printer is begonnen en het afdrukken heeft beëindigd. Maar het lastige is dat 3D-printers vaak bewegingen starten en stoppen, dus wat het beste werkte, was om de gebeurtenis "afdrukken voltooid" te definiëren die continu minstens 5 seconden moest worden gestopt. Elke beweging activeert een tweede timer die de gebeurtenis "afdrukken gestart" definieert, alleen als er geen gebeurtenis "afdrukken voltooid" plaatsvindt binnen een tijdsbestek van 15 seconden. In de praktijk werkt dit vlekkeloos

Dus de hoofdlus()-code kan onbelast worden uitgevoerd, de debounce-code wordt uitgevoerd in een RTOS-taaklus. Evenzo zijn http-verzoeken om meldingen te verzenden synchroon en daarom op de achtergrond. Zo lopen animaties soepel en stopt het tellen nooit

Er is een heleboel extra code in mijn voorbeeld om (A) een netwerkverbinding tot stand te brengen en te onderhouden met WiFi en mDNS, (B) de tijd op te halen van een NTC-server, zodat ik mijn begin- en eindmeldingen kan voorzien van een tijdstempel en een vrolijke klok kan weergeven op mijn OLED, en (C) OTA-updates afhandelen, zodat ik mijn bord niet fysiek op mijn Mac hoef aan te sluiten voor code-updates. Op dit moment staat het allemaal in één monolithisch C++-bestand, alleen omdat ik niet de tijd heb genomen om het beter te organiseren

Ik gebruikte de geweldige (en gratis) Prowl iOS-app om pushmeldingen naar mijn telefoon te sturen met niets meer dan HTTP Get-methoden

Om de code te ontwikkelen en het bord te flashen, heb ik het spectaculaire PlatformIO gebruikt dat draait op Visual Studio Code, beide gratis

Voor mijn project heb ik deze bibliotheken gebruikt: u8g2 van Oliver, elapsedMillis van Paul Stoffregen en HTTPClient van Markus Sattler, die wordt geleverd met het Espressif ESP32-platform. Al het andere wordt geleverd met de Arduino-bibliotheek of het ESP32-platform in PlatformIO

Ten slotte heb ik zes eenvoudige bitmaps van mijn hoofdkatrol onder verschillende hoeken gemaakt, zodat ik een nette kleine draaiende wielanimatie op de OLED achter de toonbank kon laten zien. Het beweegt in de juiste richting met de encoder, hoewel veel sneller voor een meer dramatisch effect

Stap 4: Bedrading

Ik heb dit zo ontworpen dat bedrading doodeenvoudig zou zijn, vooral zodat mijn behuizing klein zou kunnen zijn, maar ook dat debuggen eenvoudig zou zijn. Let op de krappe omstandigheden in mijn kleine doos.:)

De eerste vereiste was de 5V-voedingsspanning van mijn roterende encoder. Van de verschillende ESP32-ontwikkelborden die ik in mijn voorraad had, leverden er maar een paar echte 5V op de Vcc-pin wanneer ze via USB werden gevoed. (De andere maten 4,5-4,8V, wat, als je wiskunde slecht is, lager is dan 5V.) Het bord dat ik gebruikte was een Wemos Lolin32.

Vervolgens komen de twee signaalpinnen van de roterende encoder. Aangezien ik interrupts gebruik, is de grootste zorg dat de pinnen die ik gebruik nergens mee interfereren. In de ESP32-documenten staat dat ADC2 niet tegelijkertijd met WiFi kan worden gebruikt, dus dat betekent helaas dat ik geen van de ADC2 GPIO-pinnen kan gebruiken: 0, 2, 4, 12, 13, 14, 15, 25, 26 of 27. Ik koos 16 en 17.

Pro tip: als je encoder, na dit alles bij elkaar te hebben gezet, achteruit lijkt te tellen, kun je de twee pintoewijzingen in config.h gewoon omwisselen.

Sluit ten slotte de aarddraad van de roterende encoder aan op … tromgeroffel … de aardingspin.

Vervolgens wordt de nul / reset-drukknop verbonden tussen aarde en een andere vrije pin (ik koos voor GPIO 18).

De knop die ik gebruikte was een kleine tijdelijke schakelaar die ik heb gered van de bovengenoemde computermuis, maar elke knop die je hebt liggen is voldoende. Je kunt het zien rusten in een kleine houder die ik ervoor heb gemaakt, recht over het bord.

Ten slotte heeft de OLED, als deze nog niet op uw bord is aangesloten, slechts vier pinnen nodig: 3V3, aarde, i2c-klok en i2c-gegevens. Op mijn ontwikkelbord zijn klok en data respectievelijk 22 en 21.

Stap 5: Print de onderdelen uit

Ik ontwierp zeven onderdelen voor deze build:

De poelie, die direct op de as van de roterende encoder wordt gemonteerd

De spanrol, die over een 608ZZ-lager past (verwijder de schilden en ontvet met WD40 zodat deze vrij ronddraait)

De houder, waarop de twee wielen en de encoder worden gemonteerd - let op de spiraalveer voor de spanrol

Een beugel om de houder te stabiliseren. De foto in deze stap laat zien hoe de beugel aan de houder wordt bevestigd

De behuizing (onder) voor mijn ESP32-ontwikkelbord, met een ruimte voor de USB-kabel aan de zijkant en een andere aan de bovenkant voor de connector die ik aan mijn encoderdraden heb toegevoegd. Deze is ontworpen om op de Wemos Lolin32 te passen, dus je moet dit ontwerp misschien een beetje aanpassen om op een ander bord te passen

De behuizing (boven) om het OLED-scherm te houden, nog een spiraal voor de nul / reset-knop

Een knophouder aangepast voor de kleine schakelaar die ik had, ontworpen om te rusten tussen de twee planken in de onderste behuizing. Ik heb een soldeerbout gebruikt om de schakelaar op de houder te "lijmen"; zie de vorige stap voor een foto

Alles is ontworpen om te worden afgedrukt zonder steunen. Normaal PLA in de kleur naar keuze is alles wat je nodig hebt.

Zet alles bij elkaar, bevestig het aan uw printer (hier kan wat creativiteit nodig zijn) en u bent klaar om te gaan.