So richten Sie einen iDraw 2.0-Plotter und einen Raspberry Pi für den Headless-Betrieb ein

Dieser Artikel wurde von @Erez Zukerman beigesteuert.

Ich arbeite sehr gerne mit meinem iDraw 2.0-Plotter, lasse ihn aber gerne langsam laufen – daher können meine Zeichnungen eine Weile dauern. Eine Zeit lang habe ich die standardmäßige Inkscape-Einrichtung verwendet, musste dabei aber meinen Hauptcomputer eingeschaltet und mit dem Plotter verbunden lassen, während dieser arbeitete. Das war nicht ideal – deshalb wollte ich herausfinden, ob ich mithilfe eines Raspberry Pi eine „Headless“-Einrichtung realisieren kann.
Es stellte sich heraus, dass es deutlich einfacher war, als ich gedacht hatte, und außerdem Spaß gemacht hat. Folgendes werden wir tun:
●Den Pi selbst einrichten.
●CNCjs und seine Abhängigkeiten installieren. Damit steuern wir den Plotter tatsächlich, indem wir GCode über die Verbindung senden.
●Außerdem nehmen wir uns einen Moment Zeit, um alles so einzurichten, dass CNCjs bei jedem Start des Pi automatisch gestartet wird, ohne dass du dich anmelden oder etwas tun musst.
●Herausfinden, wie wir unsere SVGs in GCode umwandeln können (mit Steuerung der Stiftgeschwindigkeit).
Bitte beachte, dass dieses Tutorial voraussetzt, dass du mit der Linux-Befehlszeile vertraut bist. Wenn du es Monate oder Jahre nach der Erstveröffentlichung nachvollziehst, können unterwegs alle möglichen Fehler auftreten – das liegt in der Natur der Sache. Zum Zeitpunkt der Erstellung hat das beschriebene System bei mir gut funktioniert.
Fangen wir an!

Den Pi einrichten

Am besten verwendest du einen Pi ausschließlich für dieses Projekt, damit er dein „Plotter-Controller“ ist. Falls das nicht möglich ist, ist das kein Problem – es funktioniert trotzdem, kann aber auf Dauer weniger praktisch sein.
Ein weiterer guter Grund, einen Pi ausschließlich für dieses Projekt zu verwenden, ist, dass man ihn von Grund auf mit sinnvollen Standardeinstellungen einrichten kann. Genau das habe ich getan: Ich habe eine 32-GB-SD-Karte genommen und sie mit dem offiziellen Raspberry Pi Imager mit Raspberry Pi OS beschrieben.
Eine Sache, die das Tool ermöglicht und die ich empfehlen würde, ist, direkt ab Werk einige Standardeinstellungen festzulegen. Mit dem Installer habe ich Folgendes konfiguriert:
●Meinen Benutzernamen und mein Passwort
●Einen lokalen Hostnamen für die Plottersteuerung (in meinem Fall plotter.local)
●Meinen öffentlichen SSH-Schlüssel, damit ich mich sofort per SSH mit dem Rechner verbinden konnte
●Meine WLAN-SSID und mein WLAN-Passwort, damit sich der Pi beim Start mit meinem Netzwerk verbindet
Ich habe all das konfiguriert und dann den Imager seine Arbeit machen lassen. Als er fertig war, habe ich die microSD-Karte ausgeworfen und in den Pi gesteckt. Nur für den ersten Start habe ich den Pi mit einer Tastatur und einem Display verbunden – unbedingt nötig war das allerdings nicht. Der von mir gewählte Hostname plotter.local brauchte ein paar Augenblicke, um sich in meinem Netzwerk zu registrieren, daher habe ich mit Tastatur und Display die aktuelle IP-Adresse ermittelt (indem ich im Terminal ifconfig ausgeführt habe).
Ich hatte eine SSH-Verbindung zum Gerät hergestellt, und es war Zeit für den nächsten Schritt: CNCjs installieren.

CNCjs installieren

Wie Sie vermutlich schon am Namen erkennen, basiert CNCjs auf Node. Daher müssen wir zunächst Node installieren.
●Stellen Sie eine SSH-Verbindung zum Pi her.
●Installieren wir NVM:
○curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash
●Beenden Sie das Terminal und stellen Sie anschließend erneut eine SSH-Verbindung her. Dadurch wird NVM geladen.
●Jetzt installieren wir Node:
○nvm install node
●Großartig! Zeit, CNCjs zu installieren:
○npm install -g cncjs
●Wenn bis hierhin alles gut funktioniert hat, führen wir CNCjs nun einmal aus. Dadurch wird unsere Konfigurationsdatei ~/.cncrc erstellt:
○Führen Sie in der Befehlszeile in Ihrem Home-Verzeichnis cncjs aus.
○Beenden Sie den Editor mit Strg+C.
●Sie besitzen nun stolz eine brandneue ~/.cncrc-Datei – herzlichen Glückwunsch. Bearbeiten wir sie, hauptsächlich damit wir den Fernzugriff erlauben können:
○vi .cncrc
{
    "allowRemoteAccess": true,
    "state": {
        "allowAnonymousUsageDataCollection": false,
        "checkForUpdates": true,
        "controller": {
            "exception": {
                "ignoreErrors": false
            }
        }
    },
    "secret": YOUR_SECRET HERE
}
Die wichtigste Zeile, die hier hinzugefügt werden muss, ist die erste: allowRemoteAccess.
●Führen Sie CNCjs auf dem Pi erneut aus.
●Öffnen Sie auf Ihrem Hauptrechner im Browser plotter.local:8000. CNCjs sollte angezeigt werden.

Als Nächstes ist es Zeit, den Plotter anzuschließen und zu prüfen, ob CNCjs mit ihm kommunizieren kann.
●Verbinden Sie den Plotter iDraw 2.0 mit dem USB-Anschluss des Pi.
●Schalten Sie den Plotter ein.
●Suchen Sie in CNCjs das Widget „Verbindung“ (standardmäßig oben links).
○Klicken Sie unter „Port“ auf die Schaltfläche „Aktualisieren“.
○Öffnen Sie das Dropdown-Menü und wählen Sie den Port aus.

●Klicken Sie auf „Öffnen“. Wenn alles funktioniert hat, sollte die G-Code-Konsole nun Text anzeigen.

Bewegen wir die Motoren!

●Verwenden Sie das Widget „Achsen“ und klicken Sie bei den verschiedenen Achsen auf + und -, um die Motoren zu bewegen. Sie können auch „Tastatursteuerung“ aktivieren und anschließend die Pfeiltasten verwenden, um den Plotter zu bewegen. Wenn Sie einen Stift einsetzen und die Z-Achse absenken, ist das wie ein teures Etch-a-Sketch.

Eine Anmerkung: Die Position 0 auf der Y-Achse liegt entgegen Ihrer möglichen Erwartung am unteren Rand des Zeichenbereichs. Darauf kommen wir später zurück.

CNCjs beim Start ausführen

Als Nächstes möchten wir, dass der Pi nach jedem Neustart automatisch wieder diesen optimalen Zustand erreicht, ohne dass Sie etwas tun müssen. Also:
●Kehren Sie zur SSH-Sitzung auf dem Pi zurück und beenden Sie CNCjs mit Strg+C.
●Stelle sicher, dass es wirklich beendet wurde, indem du den Browser aktualisierst (plotter.local:8000, vorausgesetzt, dies ist der oben konfigurierte Hostname). Dies sollte nun fehlschlagen.
●Installiere pm2 auf dem Pi: npm install -g pm2
●Starte CNCjs mit pm2: pm2 start cncjs --name cncjs
●Stelle sicher, dass es tatsächlich gestartet wurde und wie erwartet funktioniert: Warte einige Augenblicke, rufe dann plotter.local:8000 auf und prüfe, ob die Seite geladen wird.
●Erstelle ein Startskript: pm2 startup. Dadurch wird ein Befehl ausgegeben, den du mit sudo ausführen musst; tue das.
●Speichere die Prozessliste: pm2 save
●Starte den Pi neu, um zu prüfen, ob es funktioniert hat: sudo reboot
●Warte, bis es wieder hochgefahren ist, möglicherweise 3–5 Minuten, und rufe dann http://plotter.local:8000/ auf, um zu prüfen, ob CNCjs wieder erreichbar ist. Wenn du alles richtig gemacht hast, sollte es direkt wieder verfügbar sein.
Geschafft! Wir sind fast da – CNCjs ist jetzt vollständig eingerichtet. Um etwas zu plotten, müssen wir es jedoch mit einer GCode-Datei versorgen – SVGs verarbeitet es nicht direkt.

Erstelle eine Pipeline zur Umwandlung von SVGs in GCode

Um unser SVG in GCode umzuwandeln, verwenden wir Juicy-Gcode, ein kleines Befehlszeilenprogramm.
Eine wichtige Änderung besteht darin, dass wir den Nullpunkt relativ zur unteren linken Ecke deines Papiers setzen, nicht zur oberen rechten! An diese Änderung musst du dich möglicherweise erst gewöhnen. Ich werde dich später noch einmal daran erinnern.
●Lade auf deinem Hauptrechner die Juicy-Gcode-Release-Binärdatei für dein Betriebssystem herunter: https://github.com/domoszlai/juicy-gcode/releases
●Die Juicy-Gcode-Konfiguration wird in einer sogenannten „Flavor-Datei“ gespeichert. Das ist einfach eine YAML-Datei. Hier ist eine gute Ausgangsdatei. Du kannst sie in flavor.yaml auf deinem Rechner kopieren/einfügen:
begin: |
  G21 ; Einheiten auf Millimeter festlegen
  G17 ; Ebenenauswahl auf XY festlegen
  G90 ; Absolute Positionierung festlegen
  F600  ; Geschwindigkeit auf 600 mm/min setzen -- das ist wirklich langsam, du möchtest dies möglicherweise ändern
  G00 Z0 ; Stift angehoben
  G92 X0 Y0 ; aktuelle Position als 0,0 festlegen -- dies ist die UNTERE LINKE Ecke
end: |
  G0Z0 ; Stift angehoben
  G00 X0 Y0 Z0
toolon: |
  G0Z6 ; Stift auf dem Papier abgesenkt
tooloff: |
  G0Z0 ; Stift angehoben
  
Ein paar wichtige Hinweise zu dieser Flavor-Datei:
●Ich betreibe den Plotter mit 600 mm/min, was sehr langsam ist. Je nach Stiften und persönlichen Vorlieben möchtest du die Geschwindigkeit möglicherweise erhöhen.
●Die andere bemerkenswerte Zeile ist die, die mit G92 beginnt. In dieser Zeile sagen wir dem Plotter: „Egal, wo du dich gerade befindest, das ist dein Ausgangspunkt.“ Um einen Plot zu kalibrieren, erwarten wir, dass du den Plotterkopf manuell (und vorsichtig) in die untere linke Ecke des Papiers bewegst.
Die Papiergröße sollte in der SVG-Datei korrekt eingerichtet sein; das ist wichtig.
Um Juicy-Gcode auszuführen, sieht der Befehl ungefähr so aus:
juicy-gcode -f flavor.yaml image.svg -o image.gcode
Das ist jedes Mal ein ziemlich langer Befehl zum Eintippen, daher habe ich dieses kleine Skript erstellt, um die Sache etwas bequemer zu machen:
#!/bin/bash
# Verwendung: ./run-juicy.sh input.svg [speed]
# Wenn keine Geschwindigkeit angegeben ist, wird standardmäßig 600 verwendet

# Prüfen, ob mindestens ein Argument angegeben wurde

if [ "$#" -lt 1 ] || [ "$#" -gt 2 ]; then
echo "Verwendung: $0 <input-svg> [speed]"
echo " Wenn keine Geschwindigkeit angegeben ist, wird standardmäßig 600 verwendet"
exit 1
fi

inputfile="$1"

# Standardgeschwindigkeit auf 600 setzen, falls nicht angegeben
speed="${2:-600}"

# Den Namen der Varianten-Datei erstellen
flavor_file="flavor-${speed}mm-speed.yaml"

# Ausgabedateinamen erzeugen, indem die .svg-Erweiterung durch .gcode ersetzt wird
outputfile="${inputfile%.*}.gcode"

# Den juicy-gcode-Befehl ausführen

juicy-gcode -f "$flavor_file" "$inputfile" -o "$outputfile"
Du kannst jetzt mehrere Dateien mit unterschiedlichen Geschwindigkeitsvarianten haben, jeweils mit einer anderen Laufgeschwindigkeit, und die Geschwindigkeit ganz einfach angeben, indem du die Zahl übergibst, die dem Dateinamen der Varianten-Datei entspricht.
Nachdem du nun eine GCode-Datei hast, ist es Zeit, sie hochzuladen und zu plotten!

GCode hochladen und plotten

CNCjs bietet uns zwei Möglichkeiten, eine GCode-Datei einzuspeisen: Wir können sie über den Browser hochladen, indem wir auf „Upload G-code“ klicken, oder wir können ein Überwachungsverzeichnis einrichten (sodass der Plotter zu laufen beginnt, sobald eine GCode-Datei darin auftaucht).
Letzteres klingt in der Theorie cool, ergibt aber nicht besonders viel Sinn: Jeder Plot erfordert ohnehin eine manuelle Einrichtung. Wir müssen das Papier einlegen, den Stift einsetzen usw. Daher ist es für mich viel sinnvoller, die Datei manuell über den Browser hochzuladen.
Zoome danach heraus, um die Vorschau zu sehen. 

Das gibt uns ein paar wichtige Plausibilitätsprüfungen:
●Wir werden noch einmal daran erinnert (…), dass der Plot vom unteren linken Rand unseres Papiers aus beginnt.
●Wir sehen die Maße sowohl auf der X- als auch auf der Y-Achse. Es lohnt sich, einen Moment innezuhalten, dies zu lesen und zu überprüfen, ob sie deinen Plotterbereich nicht überschreiten. Falls doch, stimmt etwas mit deiner SVG-Datei nicht – starte den Plotvorgang nicht, sonst wären deine Servos ziemlich unglücklich.
Vorausgesetzt, dein Stift befindet sich in der unteren linken Ecke deines Papiers und die Maße stimmen, ist es Zeit zum Plotten! Klicke auf die Wiedergabetaste und beobachte deinen Plotter. Du kannst deinen Computer jetzt herunterfahren oder in einen anderen Raum mitnehmen, während der Pi und der Plotter arbeiten. Geschafft!