TD-free! More fun?

Recently, I took you along on my journey with the TD1 from Ajax3D, sharing both the ups and downs of using it with HueForge.

Meanwhile, Mawoka thought, “There must be an easier and cheaper way!” And voilà, the TDfree was born!

What can I say? He nailed it! Even though I built the TD1 myself to save money, there were minor hiccups that raised costs and dampened my spirits. Breaking the second or third display because they’re so fragile isn’t fun. In total, I spent way more than the estimated €15 for materials and €10 for a Patreon license.

A Little Disclaimer: I’ve known Mawoka, aka Marlon, for a while and was aware of his project. So, I asked if I could review his TDfree for this blog. He agreed and, knowing my financial situation, offered me the board at cost plus shipping.

You might think: “Advertising? On this blog? Meh!” Yeah, maybe – but hey, I would have bought his board eventually and reviewed it here anyway.
So, let’s dive into this with an open mind!

Okay… enough preamble—let’s get to the star of the show: the TDfree.

TDfree

As the name suggests, it’s a FOSS version of a device used to measure the TD value of your filaments.

What’s the TD Value? It’s basically how much light can pass through a filament. The higher the value, the more light shines through, allowing you to print colorful images with HueForge.

HueForge Bild - Angus Young von AC/DC auf der Bühne stehend und den Zeigefinger Richtung Publikum zeigend.
HueForge Picture / Angus Young

There’s also a self-source version (V2) of TDfree that’s cheaper and easier to solder and assemble than Ajax3D’s version.

Today we’re focusing on version 3 of TDfree. It comes as an assembled board that you can house in a printed case or as a complete small box.

I chose the board to show you all the steps needed to make it operational. The PCB arrived quickly at my home and looked great right out of the box.

Mawoka aims to reduce waste by using small old anti-static bags for electronic components—a move I really appreciate!


A neat little feature: There’s a 3D-printed “bend protection” on the back of the board made from PHA to keep cables safe during transport.

A QR code was included with the board that led me to an installation guide.
Clear instructions with pictures are showing you exactly what to do.

The case for TDfree is available on Printables. You need to print the two small parts in black where the filament passes through; however, you can customize the case colors as you like. For simplicity, I printed them in black PETG.

black case and inner parts and a violet lid with
case of the TDfree

I added the text “TD.free” on the lid, which you can find as a remix on Printables.

Assembly was super easy! I had to remove a tiny bit of material from the PCB with a deburrer to fit it perfectly into the case—no big deal at all!

Before final assembly, check if your filament slides smoothly; adjustments may be needed due to printing inaccuracies.

Now that everything’s assembled, it’s time to power up TDfree using a standard USB-C cable with 5V from any modern phone charger.

A WiFi access point named “TD-free” appears, allowing connection with your laptop or phone. If not redirected automatically, enter: http://192.168.17.1

Screenshot des AccessPoints
TDfree Access Point Website

You can now determine your filaments’ TD values via AccessPoint or input your WLAN data in “Wifi-Config,” connecting TDfree to your network for local access.

I noticed differences between Ajax3D’s TD1 values and those from TDfree – an average deviation of -0.8.
Not an issue if you use either device exclusively but worth noting if using both devices simultaneously in HueForge or Spoolman (if applicable).

Update: With firmware 0.2.0, you can set an offset so that TDfree and TD1 values don’t differ significantly after reporting my finding to Mawoka.

So, what would I chose if I would not know anythig about those TD-determing devices and just want to start making cool 3D prints at home?

Short answer: I choose the TDfree

Long answer: It’s cheaper, smaller, easier to assemble yet reliable in determining relative TD values; its firmware is FOSS available on GitHub—simple solutions are my jam!

Moreover: no need for Patreon registration for a €10 “donation” for a tied license bound to the unique serial number of the Rpi2040 like with TD1 – not fond of such practices!

Some may miss the dispay or the HueForge integration – but personally dislike those mini-OLED displays.
Furthermore, the TD1’s color recognition doesn’t always work well enough, so I’ve switched to using eyeballing to determine the colors of my filament in HueForge anyway.


Update 2: Mawoka is working meanwhile with the HueForge developer; an integration into HueForge is expected soon though no exact ETA yet—exciting news indeed!

Consider supporting someone providing real value within HueForge community by purchasing Mawoka’s fully assembled board (€24 plus shipping) or a complete unit with case at fair price!

Thank you for reading!

PS: If financially constrained like me, contact Mawoka via shop email – you might find a solution enabling cool HueForge prints!

TDfree – weniger basteln – mehr Spaß?

Ich habe Euch letztens ja auf meine Reise zum TD1 von Ajax3D mitgenommen und von den Problemen und den Vorteilen dieses Geräts im Bezug auf HueForge berichtet.

Parallel zur Entwicklung von Ajax3D hat Mawoka sich gedacht: „Das muss doch noch einfacher und vor allem günstiger gehen!“ So entstand der TDfree!

Tja, was soll ich sagen? Damit liegt er richtig, denn auch wenn ich den TD1 selbst gebaut habe und dadurch ordentlich Kosten einsparen konnte, gab es hier kleinere Probleme, die den Preis erhöht und meine Laune gedämpft haben. Denn wenn man sich das zweite oder dritte Display schrottet, weil die einfach so unglaublich empfindlich sind, dann macht das echt nur wenig Spaß – und insgesamt hab ich inklusive Lizenz doch deutlich mehr als die veranschlagten 15€ Material und 10€ für die Lizenz via Patreon ausgegeben.

Disclaimer: Da ich Mawoka schon eine Weile kenne und von seinem Vorhaben wusste, habe ich gefragt, ob ich seinen TDfree für diesen Blog besprechen kann.
Er sagte ja und da er weiß, dass ich finanziell nicht so gut dastehe, hat er mir die Platine zum Selbstkostenpreis zuzüglich Versand überlassen.

Ihr denkt jetzt sicher: „Soso… Werbung? Hier auf dem Blog? Meh!“
Ich sage: „Ja natürlich kann man es als Werbung sehen, aber ich hätte so oder so irgendwann seine Platine gekauft und hier im Blog besprochen.“
Von daher hoffe ich, dass Ihr genau so unvoreingenommen an diesen Artikel heran geht, so wie ich es mache.

Okay… das war ein langes Vorwort – kommen wir zum Wesentlichen:
dem TDfree

Wie der Name schon fast verrät, handelt es sich um eine FOSS Variante eines Gerätes, mit dem man den so genannten TD-Wert von Filamenten bestimmen kann.

Was ist der TD-Wert? Das ist im Prinzip der Wert, den jedes Filament hat, wenn es um Lichtdurchlässigkeit geht. Je höher der Wert, desto mehr Licht kann durch das Filament scheinen und letztendlich kann man mit dem Programm HueForge tatsächlich mehrfarbige Bilder drucken. Unterschiedliche Schichtdicken werden hier für Abstufungen der jeweiligen Filamentfarbe genutzt.

Angus Young von AC/DC als dreifarbiger 3D-Druck

Beim TDfree gibt es ebenfalls eine Self-Source-Variante (V2), die einerseits deutlich günstiger ist als die Variante von Ajax3D, aber auch viel einfacher beim Löten und Zusammenbau.

Wir kümmern uns aber heute um die aktuelle Version 3 des TDfree. Diese kommt als bestückte Platine zu Euch nach Hause, wo Ihr einfach selbst noch das Gehäuse dazu drucken müsst, oder eben als fertige kleine Box.

Ich habe mich für die Platine entschieden, weil ich Euch sonst ja nicht alle Schritte zeigen kann, die es braucht, damit das Ding einsatzbereit ist.
Das PCB kam binnen kurzer Zeit bei mir Zuhause an und sah auf den ersten Blick gut aus.

Mawoka möchte möglichst viel Müll vermeiden, was ich sehr gut finde und verwendet einfach kleine alte Antistatikbeutel, wie sie für elektrische Kleinteile verwendet werden.

Eine kleine schwarze Platine, die mit einem kleinen ESP einer Diode und anderen kleinen Teilen bestückt ist.
TDfree PCB bestückt mit allen Teilen
Die Rückseite von der TDfree Platine, auf der in weiß ein Knickschutz für die zwei Kabel zum LED hin zu sehen ist.
Rückseite vom TDfree


Leider hatte Mawoka, der das Ganze ja auch nur als Kleinstunternehmer betreibt, leider gerade kein technisches Isolierband mehr da, so dass das mit dem Tesafilm doch ein bisschen Gefrickel war, das zu entfernen. Aber das sollte bei zukünftigen Besteller*innen nicht mehr vorkommen, hat er mir gesagt.


Was ich eine kleine, aber richtig gute Sache finde:
Auf der Rückseite der Platine ist ein selbst gedruckter „Knickschutz“ aus PHA, damit das Kabel zum LED-Modul während des Transports keinen Schaden nehmen kann.

Neben der Platine lag noch ein QR-Code bei, der mich dann auf die Installationsanleitung geführt hat.

Diese ist detailreich und auf den Bildern dort sieht man genau, worauf man achten sollte.

Das Gehäuse für den TDfree ist auf Printables zu finden und man muss zwingend die beiden kleinen Teile, wo das Filament durch das Gehäuse geführt wird, in schwarz drucken – Gehäuse und Cover könnt Ihr aber farblich gestalten wie ihr mögt.
Ich habe hier der Einfachheit halber den unteren Teil des Gehäuses und die beiden Kleinteile im schwarzen PETG gedruckt.

Den Deckel habe ich mit dem Schriftzug „TD.free“ versehen, welchen Ihr als Remix auch auf Printables finden könnt.

Der Zusammenbau gestaltete sich super einfach. Ich musste am PCB ein ganz kleines bisschen Material mit einem Entgrater abnehmen, damit die Platine auch perfekt in das Gehäuse passt.
Das ist überhaupt nicht schlimm und wir sprechen hier von ein paar µm und an den Seiten ist mehr als genug PCB-Material, dass die vielleicht 0.02mm weniger überhaupt nicht ins Gewicht fallen. Aber ich wollte es erwähnen, weil Druckungenauigkeiten immer mal vorkommen können und es nicht an der Platine liegt, sondern an meinem Druck des Gehäuses.


Es bietet sich auch an, dass Ihr vor dem finalen Zusammenbau einmal prüft, ob durch den „Schlitten“ Euer Filament auch problemlos hin und her zu schieben ist. Hier muss/sollte eventuell auch ein wenig nachgearbeitet werden. Druckungenauigkeiten… ihr wisst schon!

So… da nun alles zusammen gebaut ist, wird es Zeit den TDfree das erste Mal mit Strom zu versorgen. Das macht man mit einem normalen USB-C Kabel und 5V, wie es aus jedem Ladegerät für Mobiltelefone der heutigen Zeit kommt.

Daraufhin spannt sich ein Wifi-AccessPoint mit dem Namen „TD-free“ auf, mit dem man sein Laptop oder Handy verbinden kann.

Falls ihr nicht direkt auf die Portalseite gelenkt werdet, gebt als Adresse: http://192.168.17.1 ein und dann solltet ihr folgendes Bild sehen:

TDfree AccessPoint WebUI

Das war es auch schon… ihr könnt nun entweder über den AccessPoint den TD-Wert Eurer Filamente bestimmen, oder über die „Wifi-Config“ die Daten von Eurem eigenem WLAN eingeben dann verbindet sich der TDfree mit Eurem WLAN und stellt die Webseite, die ihr oben gesehen habt in Eurem lokalen Netz bereit. Hierzu muss man dann im Router schauen, welche IP der TDfree erhalten hat. Das klappte bei mir ganz hervorragend und so konnte ich herrlich unkompliziert die Werte von diversen Rollen Filament nehmen.

Was mir aber schnell aufgefallen ist: Die Werte vom TD1 von Ajax3D und dem hier getesteten TDfree unterscheiden sich.
Ich habe hier im Durchschnitt eine Abweichung von -0.8

Das ist prinzipiell nicht schlimm, wenn ich davon ausgehe, dass ihr entweder einen TD1 habt oder eben einen TDfree – und nicht wie ich beide Geräte.

Falls doch, solltet ihr aber im HUEForge und im Spoolman, sofern ihr den verwendet, irgendwo markieren, dass ihr den TD-Wert vom TDfree oder TD1 genommen habt.
Also zum Beispiel im Filamentnamen; „black-matte-TDfree“ oder so – damit ihr in HueForge nicht versehentlich beide Werte untereinander mixt. (Ich hoffe ihr versteht, worauf ich hinaus möchte)

Update: mit der aktuellen Firmware 0.2.0 gibt es die Möglichkeit ein Offset einzustellen, damit sich die Werte vom TDfree und dem TD1 nicht gravierend unterscheiden. Das hatte Mawoka überlegt, nachdem ich ihm von der von mir entdeckten Differenz berichtet habe.

Die Ergebnisse sind dann aber absolut vergleichbar. Wie ihr hier sehen könnt:


Zusammengefasst, verrate ich Euch, welches der beiden Geräte ich lieber mag:

Kurze Antwort: den TDfree

Lange Antwort: er ist deutlich günstiger, kleiner, einfacher im Zusammenbau, genauso Zuverlässig in der Bestimmung der relativen TD-Werte und die Firmware ist Open Source und auf Github komplett einsehbar. Ich mag FOSS – ich mag es simpel.

Außerdem braucht man sich nicht auf einer Plattform wie Patreon zu registrieren, um dann 10€ “zu spenden”, damit man eine Lizenz bekommt, welches an die Seriennummer des TD1 gebunden ist.
Ja, ich hab das hinter mir, aber wirklich glücklich finde ich das Vorgehen beim TD1 eben nicht.

Einigen wird vermutlich das Display und die Schnittstelle zu HueForge fehlen, aber ich persönlich stehe mit den Mini-OLED-Displays auf Kriegsfuß und auch der zusätzliche Farbsensor im TD1 liefert auch nicht immer den richtigen Wert, wie ich im Laufe der Zeit feststellen musste. Da kann ich jetzt auch, wie zuvor, einfach die Farbe in HueForge per Hand bestimmen.

Update 2: Mawoka steht mit dem Entwickler vom HueForge in Kontakt und es sieht ganz danach aus, dass es in absehbarer Zeit eine Integration in HueForge geben wird. Ein genaues Datum gibt es zwar noch nicht, aber es ist toll zu wissen, dass daran auch gearbeitet wird.

Falls Ihr Euch also vorstellen könnt, einen ambitionierten Menschen, der einen echten Mehrwert für die HueForge-Community leistet, zu unterstützen, dann besorgt Euch zu einem in meinen Augen sehr fairen Preis von 24€ plus Versand die fertig bestückte Platine oder für einen kleinen Aufpreis den fertig zusammen gebauten TDfree von Mawoka

PS: Ich habe mit Mawoka gesprochen und falls es Menschen unter Euch gibt, die wie ich finanziell nicht ganz so gut dastehen, dann schickt ihm gerne eine Email an die Adresse, die im Shop zu sehen ist – eventuell findet ihr eine gute Lösung, so dass Ihr auch coole Bilder mit HueForge drucken könnt.

Vielen Dank fürs Lesen!

PPS: English version will be ready soon!

Spoolman behind a Traefik-Proxy in the internal network

German version below:

Spoolman is a great too to track your filament usage and Sebastian already described the setup. I’m also running Spoolman in my internal network. The software got multiple user interfaces or integrations so that you can use it standalone in a browser or integrate a widget into Klippers User interface.

The integration into Moonraker (the Web Interface for Klipper) currently doesn’t have the ability to provide any credentials for Moonrakers Spoolman integration to authenticate against Spoolman.

If you want to expose Spoolman to the Internet to check your filament usage from outside your homework you surely want authentication. Spoolman doesn’t offer any user management at all at the moment. So you have to user a normal web server or proxy to add some authentication.

In my personal setup I’m using Traefik reverse proxy to expose Spoolman running in a Docker container to the internet and handle the SSL certificates. SSL is also required to make use of Spoolmans feature to scan QR codes of your spools.

The requirements in my setup are: do not require a password when requests come from the local network (192.168.1.0/24); do require HTTP Basic authentication when request comes from the outside Internet.

This way the integration into my Klipper setup doesn’t require authentication but accessing Spoolman from the internet does.

While this would be relatively straightforward with Apache HTTPD it was a bit tricky with Traefik.

My solution is to define two http.routers in Traefik for Spoolman. One for access from the internal network:

- "traefik.http.routers.spoolman-internal.rule=( Host(`spoolman.example.net`) && ClientIP(`192.168.1.0/24` ))"

and one for access from the outside Internet:

- "traefik.http.routers.spoolman.rule=Host(`spoolman.example.net`) && !ClientIP(`192.168.1.0/24` )"
- "traefik.http.routers.spoolman.entrypoints=websecure"

Both http.routers then can have their own Traefik middlewares section to add authentication or not.

My whole Spoolman docker-compose.yaml looks like this:

version: '3.8'
services:
  spoolman:
    image: ghcr.io/donkie/spoolman:latest
    restart: unless-stopped
    labels:
       - "traefik.enable=true"
       - "traefik.http.routers.spoolman-internal.rule=( Host(`spoolman.example.net`) && ClientIP(`192.168.1.0/24` ))"
       - "traefik.http.routers.spoolman-internal.entrypoints=websecure"
       - "traefik.http.routers.spoolman.rule=Host(`spoolman.example.net`) && !ClientIP(`192.168.1.0/24` )"
       - "traefik.http.routers.spoolman.entrypoints=websecure"
       - "traefik.http.routers.spoolman.tls=true"
       - "traefik.http.routers.spoolman.priority=2"
       - "traefik.http.routers.spoolman.tls.certresolver=letsencrypt"
       - "traefik.http.routers.spoolman-internal.tls.certresolver=letsencrypt"
       - "traefik.http.routers.spoolman.middlewares=auth-users"
       - "traefik.http.routers.spoolman-internal.tls=true"
       - "traefik.http.routers.spoolman-internal.priority=1"
       - "traefik.http.routers.spoolman.service=svc-spoolman"
       - "traefik.http.routers.spoolman-internal.service=svc-spoolman"
       - "traefik.http.services.svc-spoolman.loadbalancer.server.port=8000"
       - "traefik.http.middlewares.auth-users.basicauth.users=admin:$$2U$$07$$K3XvlqQOC3ScMoRqOIQ50elXe.QByrAvpvmaDp9yj0oaA4LOLiCE6"
    networks:
      - web
    volumes:
      # Mount the host machine's ./data directory into the container's /home/app/.local/share/spoolman directory
      - type: bind
        source: ./data # This is where the data will be stored locally. Could also be set to for example `source: /home/pi/printer_data/spoolman`.
        target: /home/app/.local/share/spoolman # Do NOT change this line
    ports:
      # Map the host machine's port 7912 to the container's port 8000
      - target: 8000
        published: 7912
        protocol: tcp
        mode: host
    environment:
      - TZ=Europe/Stockholm # Optional, defaults to UTC

networks:
  web:
    name: web
    external: true

German version:

Spoolman ist ein echt tolles Tool, um den Filamentverbrauch zu verfolgen, und Sebastian hat die Einrichtung bereits beschrieben.
Ich verwende Spoolman auch in meinem internen Netzwerk. Die Software hat mehrere Benutzeroberflächen oder Integrationen, so dass man sie eigenständig in einem Browser verwenden oder ein Widget in Klippers Benutzeroberfläche integrieren kann.

Die Integration in Moonraker (das Web-Interface für Klipper) bietet derzeit keine Möglichkeit, Anmeldedaten für Moonrakers Spoolman-Integration bereitzustellen, um sich gegenüber Spoolman zu authentifizieren.

Wenn Sie Spoolman dem Internet aussetzen wollen, um Ihre Filamentnutzung von außerhalb Ihres Hauses zu überprüfen, brauchen Sie sicherlich eine Authentifizierung. Spoolman bietet zur Zeit keine Benutzerverwaltung an. Sie müssen also einen normalen Webserver oder Proxy verwenden, um eine Authentifizierung hinzuzufügen.

In meinem persönlichen Setup verwende ich Traefik als Reverse Proxy, um Spoolman, das in einem Docker-Container läuft, dem Internet auszusetzen und die SSL-Zertifikate zu verwalten. SSL ist auch erforderlich, um Spoolmans Funktion zum Scannen von QR-Codes Ihrer Spools nutzen zu können.

Die Anforderungen in meinem Setup sind: kein Kennwort erforderlich, wenn Anfragen aus dem lokalen Netzwerk (192.168.1.0/24) kommen; HTTP Basic Authentication erforderlich, wenn Anfragen von außerhalb des Internets kommen.

Auf diese Weise ist für die Integration in mein Klipper-Setup keine Authentifizierung erforderlich, für den Zugriff auf Spoolman aus dem Internet jedoch schon.

Während dies mit Apache HTTPD relativ einfach zu bewerkstelligen wäre, war es mit Traefik etwas knifflig.

Meine Lösung ist, in Traefik zwei http.routers für Spoolman zu definieren. Einer für den Zugriff aus dem internen Netzwerk:

- "traefik.http.routers.spoolman-internal.rule=( Host(`spoolman.example.net`) && ClientIP(`192.168.1.0/24` ))"

und einen für den Zugriff aus dem Internet:

- "traefik.http.routers.spoolman.rule=Host(`spoolman.example.net`) && !ClientIP(`192.168.1.0/24` )"
- "traefik.http.routers.spoolman.entrypoints=websecure"

Beide http.router können dann ihre eigene Traefik-Middlewares-Sektion haben, um Authentifizierung hinzuzufügen oder nicht.

Mein ganzes Spoolman docker-compose.yaml sieht wie folgt aus:

version: '3.8'
services:
  spoolman:
    image: ghcr.io/donkie/spoolman:latest
    restart: unless-stopped
    labels:
       - "traefik.enable=true"
       - "traefik.http.routers.spoolman-internal.rule=( Host(`spoolman.example.net`) && ClientIP(`192.168.1.0/24` ))"
       - "traefik.http.routers.spoolman-internal.entrypoints=websecure"
       - "traefik.http.routers.spoolman.rule=Host(`spoolman.example.net`) && !ClientIP(`192.168.1.0/24` )"
       - "traefik.http.routers.spoolman.entrypoints=websecure"
       - "traefik.http.routers.spoolman.tls=true"
       - "traefik.http.routers.spoolman.priority=2"
       - "traefik.http.routers.spoolman.tls.certresolver=letsencrypt"
       - "traefik.http.routers.spoolman-internal.tls.certresolver=letsencrypt"
       - "traefik.http.routers.spoolman.middlewares=auth-users"
       - "traefik.http.routers.spoolman-internal.tls=true"
       - "traefik.http.routers.spoolman-internal.priority=1"
       - "traefik.http.routers.spoolman.service=svc-spoolman"
       - "traefik.http.routers.spoolman-internal.service=svc-spoolman"
       - "traefik.http.services.svc-spoolman.loadbalancer.server.port=8000"
       - "traefik.http.middlewares.auth-users.basicauth.users=admin:$$2U$$07$$K3XvlqQOC3ScMoRqOIQ50elXe.QByrAvpvmaDp9yj0oaA4LOLiCE6"
    networks:
      - web
    volumes:
      # Mount the host machine's ./data directory into the container's /home/app/.local/share/spoolman directory
      - type: bind
        source: ./data # This is where the data will be stored locally. Could also be set to for example `source: /home/pi/printer_data/spoolman`.
        target: /home/app/.local/share/spoolman # Do NOT change this line
    ports:
      # Map the host machine's port 7912 to the container's port 8000
      - target: 8000
        published: 7912
        protocol: tcp
        mode: host
    environment:
      - TZ=Europe/Stockholm # Optional, defaults to UTC

networks:
  web:
    name: web
    external: true

[Teil 2] Spoolman – Klipper Installation

English below:

Die Installation von Spoolman auf dem Raspberry (oder MKS-Mainboard), wo Klipper drauf läuft ist so simpel wie so viele andere Klipper-Plugins – es wird lediglich ein auf Debian basiertes Image vorrausgesetzt.

sudo apt-get update && \
sudo apt-get install -y curl jq && \
mkdir -p ./Spoolman && \
source_url=$(curl -s https://api.github.com/repos/Donkie/Spoolman/releases/latest | jq -r '.assets[] | select(.name == "spoolman.zip").browser_download_url') && \
curl -sSL $source_url -o temp.zip && unzip temp.zip -d ./Spoolman && rm temp.zip && \
cd ./Spoolman && \
bash ./scripts/install_debian.sh

So wird es zumindest in der Anleitung beschrieben.

Ich hingegen habe ich mich dazu entschlossen Spoolman auf einem anderen Host mit Hilfe von Docker zu installieren, da ich eh eine VM in meinem Netzwerk habe, die diverse Docker-Container bereit stellt.

Ich wiederhole einfach nur noch schnell einmal die Grundinstalltion, wie ich sie auch schon im Teil 1 von der Spoolman-Anleitung beschrieben habe.

Die entsprechende docker-compose.yml sieht dann in etwa so aus:

version: '3.8'
services:
  spoolman:
    image: ghcr.io/donkie/spoolman:latest
    restart: always
    volumes:
      # Mount the host machine's ./data directory into the container's /home/app/.local/share/spoolman directory
      - type: bind
        source: ./data # This is where the data will be stored locally. Could also be set to for example `source: /home/pi/printer_data/spoolman`.
        target: /home/app/.local/share/spoolman # Do NOT change this line
    ports:
      # Map the host machine's port 7912 to the container's port 8000
      - "7912:8000"
    environment:
      - TZ=Europe/Berlin# Optional, defaults to UTC

Wenn man also den Container installiert und am Laufen hat, dann reicht eine einfache Änderung der moonraker.conf in Klipper um Spoolman hinzuzufügen:

# moonraker.conf

[spoolman]
server: http://192.168.10.123:7912
#   URL to the Spoolman instance. This parameter must be provided.
sync_rate: 5
#   The interval, in seconds, between sync requests with the
#   Spoolman server.  The default is 5.

Und in die printer.cfg wird dann noch folgendes ergänzt:

# printer.cfg

[gcode_macro SET_ACTIVE_SPOOL]
gcode:
  {% if params.ID %}
    {% set id = params.ID|int %}
    {action_call_remote_method(
       "spoolman_set_active_spool",
       spool_id=id
    )}
  {% else %}
    {action_respond_info("Parameter 'ID' is required")}
  {% endif %}

[gcode_macro CLEAR_ACTIVE_SPOOL]
gcode:
  {action_call_remote_method(
    "spoolman_set_active_spool",
    spool_id=None
  )}

Und das war es schon – nach einem Neustart von Klipper sieht es dann so aus:

Es gibt sogar eine Integration in Home Assistant um sich dort auch die Spulen anzeigen zu lassen.

Die Einrichtung ist relativ einfach und quasi selbsterklärend.
Hier gibt es die entsprechenden Infos: Home Assistant Spoolman

PS: Damit man auch die QR Codes, die man mit Spoolmann erstellt und ausgedruckt hat lesen kann, braucht es zwingend eine https-Verbindung zu Spoolman. Das ist seitens der Browserhersteller wie Mozilla oder Google so vorgegeben.

Ich habe das ganz einfach per Nginx Proxy Manager gelöst in dem ich eine neue Subdomain angelegt habe und diese dann per Letsencrypt mit einem SSL-Zertifikat ausgestattet habe.
Aber nun ist Spoolman offen aus dem Internet erreichbar?
Ja, aber mit Hilfe einer Access List (z.B. local-only) im Nginx Proxy Manager und der entsprechenden Einstellung bei der Subdomain, dass diese Access List benutzt werden soll, habe ich so eine HTTP-Auth Passwortabfrage eingerichtet und nur Personen mit entsprechendem Passwort kommen an das Webinterface von Spoolman.

@maxheadroom hat das aber auch irgendwie in seinem Traefik-Container lösen können und schreibt hier darüber: Klick

English version:

The installation of Spoolman on the Raspberry Pi (or MKS mainboard) running Klipper is as simple as so many other Klipper plugins – it only requires a Debian based system.

sudo apt-get update && \
sudo apt-get install -y curl jq && \
mkdir -p ./Spoolman && \
source_url=$(curl -s https://api.github.com/repos/Donkie/Spoolman/releases/latest | jq -r '.assets[] | select(.name == "spoolman.zip").browser_download_url') && \
curl -sSL $source_url -o temp.zip && unzip temp.zip -d ./Spoolman && rm temp.zip && \
cd ./Spoolman && \
bash ./scripts/install_debian.sh

At least that’s how it’s described in the instructions.

However, I decided to install Spoolman on another host using Docker, as I already have a VM in my network that provides various Docker containers.

I’ll just quickly repeat the basic installation as I described in part 1 of the Spoolman guide.

The corresponding docker-compose.yml then looks something like this:

version: '3.8'
services:
  spoolman:
    image: ghcr.io/donkie/spoolman:latest
    restart: always
    volumes:
      # Mount the host machine's ./data directory into the container's /home/app/.local/share/spoolman directory
      - type: bind
        source: ./data # This is where the data will be stored locally. Could also be set to for example `source: /home/pi/printer_data/spoolman`.
        target: /home/app/.local/share/spoolman # Do NOT change this line
    ports:
      # Map the host machine's port 7912 to the container's port 8000
      - "7912:8000"
    environment:
      - TZ=Europe/Berlin# Optional, defaults to UTC

So if you have the container installed and running, a simple change to moonraker.conf in Klipper is enough to add Spoolman:

# moonraker.conf

[spoolman]
server: http://192.168.10.123:7912
#   URL to the Spoolman instance. This parameter must be provided.
sync_rate: 5
#   The interval, in seconds, between sync requests with the
#   Spoolman server.  The default is 5.

And the following is then added to printer.cfg:

# printer.cfg

[gcode_macro SET_ACTIVE_SPOOL]
gcode:
  {% if params.ID %}
    {% set id = params.ID|int %}
    {action_call_remote_method(
       "spoolman_set_active_spool",
       spool_id=id
    )}
  {% else %}
    {action_respond_info("Parameter 'ID' is required")}
  {% endif %}

[gcode_macro CLEAR_ACTIVE_SPOOL]
gcode:
  {action_call_remote_method(
    "spoolman_set_active_spool",
    spool_id=None
  )}

And that’s it – after restarting Klipper, it looks like this:

There is even an integration in Home Assistant to display the reels there too.

The setup is relatively simple and virtually self-explanatory.
You can find the relevant information here: Home Assistant Spoolman

PS: In order to be able to read the QR codes that you have created and printed with Spoolman, an https connection to Spoolman is required. This is specified by browser manufacturers such as Mozilla or Google.

I solved this quite simply using Nginx Proxy Manager by creating a new subdomain and then equipping it with an SSL certificate using Letsencrypt.
But now Spoolman is openly accessible from the Internet?
Yes, but with the help of an access list (e.g. local-only) in the Nginx Proxy Manager and the corresponding setting in the subdomain that this access list should be used, I have set up an HTTP-Auth password query and only people with the corresponding password can access the Spoolman web interface.

However, @maxheadroom has also been able to solve this somehow in his Traefik container and writes about it here: Click

[Teil 1] Spoolman – track your filament… hab ich noch grünes PETG?

English below:

Neulich bin ich durch Zufall im Discord vom Mainsail-Projekt auf “Spoolman” gestoßen. Ein Klipper-Plugin, von dem ich bis dato noch nie was gehört habe, welches dazu gedacht ist endlich ein wenig Ordnung in sein vorhandenes Filament zu bringen.

In einer Datenbank werden Hersteller, Farbe, Art und Gewicht Deiner Filamente getrackt und mit Hilfe des Klipper-Plugins wird der Verbrauch direkt subtrahiert. So kannst Du weitestgehend genau sagen, wie viel Du noch von Filament X hast und kannst entscheiden, ob Dein nächster Druck damit noch möglich ist oder ob Du lieber nachbestellen solltest oder eben in einer anderen Farbe drucken möchtest.

Das Projekt findest Du hier: https://github.com/Donkie/Spoolman
… und es lässt sich sehr leicht anhand der Anleitung dort installieren.

Ich habe es als Docker-Version installiert, da ich auf einem meiner Hosts eh mehrere Docker-Projekte laufen habe.

Und so sieht die docker-compose.yml aus:

version: '3.8'
services:
  spoolman:
    image: ghcr.io/donkie/spoolman:latest
    restart: unless-stopped
    volumes:
      # Mount the host machine's ./data directory into the container's /home/ap>
      - type: bind
        source: ./data # This is where the data will be stored locally. Could a>
        target: /home/app/.local/share/spoolman # Do NOT change this line
    ports:
      # Map the host machine's port 7912 to the container's port 8000
      - "7912:8000"
    environment:
      - TZ=Europe/Berlin # Optional, defaults to UTC

Wenn man alles also eingerichtet hat, beginnt man damit seine Filamente zu erfassen.

Ich rate dazu zunächst mit den Herstellern anzufangen und sich dann über die einzelnen Filamentsorten bis hin zur einzelnen Spule zu arbeiten.

Um auch die Dichte der jeweiligen Filamentsorten richtig zu erfassen, emofehle ich diese Webseite:
https://www.simplify3d.com/resources/materials-guide/properties-table/

Dort steht unter Density für die jeweilige Sorte auch der entsprechend richtige Wert. Bei PLA wäre das zum Beispiel: 1,24 g/cm³

Am Ende sieht es dann in etwa so aus:

Und wie man sehen kann, habe ich überhaupt kein grünes PETG Filament. 😀

Im nächsten Teil werden wir dann mal sehen, wie das Ganze dann in Klipper integriert wird und wie einfach es dann ist selbst bei einem Filamentwechsel während des Drucks die entsprechenden Spulen auszuwählen.

English:

[Part 1] Spoolman – track your filament… do I still have some green PETG left?

I recently came across “Spoolman” by chance in the Mainsail project’s Discord. A Klipper plugin that I had never heard of before, which is designed to finally bring some order to your existing filament.

The manufacturer, color, type and weight of your filaments are tracked in a database and the consumption is subtracted directly with the help of the Klipper plugin. This way you can tell exactly how much of filament X you have left and can decide whether your next print is still possible with it or whether you should rather reorder or print in a different color.

You can find the project here: https://github.com/Donkie/Spoolman
… and it is very easy to install using the instructions there.

I installed it as a Docker container because I have several Docker projects running on one of my hosts anyway.

And this is what docker-compose.yml looks like:

version: '3.8'
services:
  spoolman:
    image: ghcr.io/donkie/spoolman:latest
    restart: unless-stopped
    volumes:
      # Mount the host machine's ./data directory into the container's /home/ap>
      - type: bind
        source: ./data # This is where the data will be stored locally. Could a>
        target: /home/app/.local/share/spoolman # Do NOT change this line
    ports:
      # Map the host machine's port 7912 to the container's port 8000
      - "7912:8000"
    environment:
      - TZ=Europe/Berlin # Optional, defaults to UTC

Once you have set everything up, you can start to record your filaments.

I recommend starting with the manufacturers first and then working your way through the individual filament types right down to the individual spools.

To correctly record the density of the respective filament types, I recommend this website:
https://www.simplify3d.com/resources/materials-guide/properties-table/

There, under Density, you will also find the correct value for the respective type. For PLA, for example, this would be: 1.24 g/cm³

In the end, it looks something like this:


And as you can see, I do not have any green PETG filament at all. 😀

In the next part, we will see how the whole thing is integrated into Klipper and how easy it is to select the appropriate spools even when changing filament during printing.