Projekt: OctoPrint auf dem Raspberry Pi installieren

Dieses Mal wird es etwas umfangreicher. So umfangreich, dass ich das Video in zwei Teile teilen musste. Wir installieren gemeinsam Schritt für Schritt OctoPrint auf unserem Raspberry Pi. In meinem Fall ein Raspberry Pi 4. Ziel ist es, den 3D-Drucker (einen Snapmaker) von überall steuern zu können und neue Aufträge starten zu können. Dabei kann ich dann mit der Webcam den Prozess überwachen. Später lasse ich mich dann noch mit Bildern über den Fortschritt informieren. In diesem Projekt installieren wir aber erstmal OctoPrint, Konfigurieren den Drucker und die Oberfläche, sodass wir am Ende Zeitraffer von unserem Druck herunterladen können.

Was wird benötigt?

• Ein Raspberry Pi mit Raspbian / Raspi OS
• Ein Snapmaker (oder anderer 3D-Drucker mit USB-Port)
• Eine Logitech C270 (oder andere Webcam)

Video

Befehle

Wir starten mit ein Befehlen aus dieser Anleitung.

sudo apt update
sudo apt upgrade
sudo apt install -y python3 python3-pip python3-dev python3-setuptools python3-venv git libyaml-dev build-essential libffi-dev libssl-dev

cd
python3 -m venv OctoPrint
OctoPrint/bin/pip install OctoPrint

sudo usermod -a -G tty pi
sudo usermod -a -G dialout pi

./OctoPrint/bin/octoprint serve

Danach kann unter Port 5000 im Browser der Wizard gestartet werden. Wie genau das geht, wird im Video gezeigt.

Um OctoPrint dann beim Systemstart automatisch starten zu lassen, muss folgendes ausgeführt werden:

wget https://github.com/foosel/OctoPrint/raw/master/scripts/octoprint.service && sudo mv octoprint.service /etc/systemd/system/octoprint.service
sudo chown root:root /etc/systemd/system/octoprint.service
sudo systemctl enable octoprint.service
sudo service octoprint start

Kamera

Weiter geht es mit der Installation von MJPEG-Streamer. Dieser stellt einen Webserver bereit, welcher uns Zugriff auf die Webcam erlaubt. Die zur Verfügung gestellten Streams werden dann einfach in OctoPrint konfiguriert.

cd
sudo apt install -y git libjpeg62-turbo-dev imagemagick ffmpeg libv4l-dev cmake
git clone https://github.com/jacksonliam/mjpg-streamer.git
cd mjpg-streamer/mjpg-streamer-experimental
export LD_LIBRARY_PATH=.
make

Dann können wir das Ganze auch schon testen. Der zweite Aufruf enthält die angepassten Parameter für die Auflösung der Logitech C270 und passt die Framerate auf 30 fps an. Für andere Kameras muss man hier natürlich mit anderen Parametern arbeiten.

./mjpg_streamer -i "./input_uvc.so" -o "./output_http.so"
./mjpg_streamer -i "./input_uvc.so -r 1280x720 -f 30" -o "./output_http.so"

Was jetzt noch fehlt ist die Integration der Webcam. Diese lief ja bis gerade auch nur im aktiven Terminal und startet sich nicht automatisch. Genau das ändern wir jetzt. Die Anleitung dafür habe ich aus dem Wiki von OctoPrint, allerdings habe ich den Code hier direkt an die C270 angepasst.

mkdir /home/pi/scripts/
nano /home/pi/scripts/webcam

In diese Datei kommt der folgende Inhalt:

#!/bin/bash
# Start / stop streamer daemon

case "$1" in
    start)
        /home/pi/scripts/webcamDaemon >/dev/null 2>&1 &
        echo "$0: started"
        ;;
    stop)
        pkill -x webcamDaemon
        pkill -x mjpg_streamer
        echo "$0: stopped"
        ;;
    *)
        echo "Usage: $0 {start|stop}" >&2
        ;;
esac

Die Datei wird gespeichert und geschlossen. In die zweite Datei kommt folgendes:

nano /home/pi/scripts/webcamDaemon

#!/bin/bash

MJPGSTREAMER_HOME=/home/pi/mjpg-streamer/mjpg-streamer-experimental
MJPGSTREAMER_INPUT_USB="input_uvc.so"
MJPGSTREAMER_INPUT_RASPICAM="input_raspicam.so"

# init configuration
camera="auto"
camera_usb_options="-r 1280x720 -f 30"
camera_raspi_options="-fps 10"

if [ -e "/boot/octopi.txt" ]; then
    source "/boot/octopi.txt"
fi

# runs MJPG Streamer, using the provided input plugin + configuration
function runMjpgStreamer {
    input=$1
    pushd $MJPGSTREAMER_HOME
    echo Running ./mjpg_streamer -o "output_http.so -w ./www" -i "$input"
    LD_LIBRARY_PATH=. ./mjpg_streamer -o "output_http.so -w ./www" -i "$input"
    popd
}

# starts up the RasPiCam
function startRaspi {
    logger "Starting Raspberry Pi camera"
    runMjpgStreamer "$MJPGSTREAMER_INPUT_RASPICAM $camera_raspi_options"
}

# starts up the USB webcam
function startUsb {
    logger "Starting USB webcam"
    runMjpgStreamer "$MJPGSTREAMER_INPUT_USB $camera_usb_options"
}

# we need this to prevent the later calls to vcgencmd from blocking
# I have no idea why, but that's how it is...
vcgencmd version

# echo configuration
echo camera: $camera
echo usb options: $camera_usb_options
echo raspi options: $camera_raspi_options

# keep mjpg streamer running if some camera is attached
while true; do
    if [ -e "/dev/video0" ] && { [ "$camera" = "auto" ] || [ "$camera" = "usb" ] ; }; then
        startUsb
    elif [ "`vcgencmd get_camera`" = "supported=1 detected=1" ] && { [ "$camera" = "auto" ] || [ "$camera" = "raspi" ] ; }; then
        startRaspi
    fi

    sleep 120
done

Das war es eigentlich auch schon. Theoretisch könnte die Datei noch gekürzt werden, da diese irgendwelche Unterscheidungen für die Raspberry-Kamera enthält. Aber das tut jetzt nicht weh. Ist einfach nur ein Check und ein paar Zeilen Code mehr als wir brauchen. Aber funktioniert natürlich auch so. Die beiden Dateien werden dann noch ausführbar gemacht:

chmod +x /home/pi/scripts/webcam
chmod +x /home/pi/scripts/webcamDaemon

Fertig! Als letztes wird noch die config.yaml um folgende Einträge erweitert, sodass wir die Kamera auch über die Oberfläche starten und stoppen können. Dann läuft diese eben nur, wenn wir auch einen Druck starten wollen. Ist ganz praktisch und schont auch die Kamera ein wenig.

nano ~/.octoprint/config.yaml

system:
  actions:
  - action: streamon
    command: /home/pi/scripts/webcam start
    confirm: false
    name: Start video stream
  - action: streamoff
    command: /home/pi/scripts/webcam stop
    confirm: false
    name: Stop video stream

Das wars. Die restliche Konfiguration wird im Video gezeigt. Soweit steht jetzt also die Basis für unsere weiteren Projekte. Wie schon gesagt, wird OctoPrint noch in ioBroker integriert (fhem habe ich bereits gezeigt), sodass ich den Drucker mit einem Zwischenstecker abschalten kann wenn der Druck fertig ist (und alles abgekühlt ist). Weiterhin kann ich mit über den Stream Fotos holen, welche ich dann per Telegram an mich schicken lasse. So bin ich auch unterwegs über den Druckstatus informiert. Aber dazu in einem weiteren Video später mehr.

Als URL konfigurierst Du dann in OctoPrint noch die folgende URLs:

http://172.16.0.56:8080/?action=stream
http://172.16.0.56:8080/?action=snapshot

Hier noch die alten Videos von 2018 mit dem Anycubic i3 Mega:

Video 1

Video 2

Komponenten

Installation der Cura-Engine

Als nächstes muss die CuraEngine geladen und kompiliert werden. Stand heute, dürfen die neueren Versionen (2.x, 3.x) nicht genutzt werden, da diese nicht mit OctoPrint kompatibel sind. Daher müssen wir älteren 15.04.xx Versionen nutzen. Die Versionsnummern sind etwas verwirrend. 15 ist also älter 2 oder 3. Eine Anleitung gibt es hier. Alle nötigen Befehle sind aber ebenfalls nachfolgend aufgeführt.

sudo apt-get install gcc g++

git clone https://github.com/Ultimaker/CuraEngine.git
cd CuraEngine/
git checkout tags/15.04.6
cd ..
make -C CuraEngine

Das dauert dann auch wieder eine ganze Weile. Gerade auf meinem alten Raspberry Pi der ersten Generation ist das ziemlich zeitintensiv.

Als nächstes Drucken wir dann den Kamera-Arm. Dieser positioniert unsere Webcam so, dass wir den laufenden Druck gut beobachten können. Das Ganze wird mit ein paar Schrauben zusammengebaut (sind oben verlinkt). Ich habe die 6mm-Variante gedruckt. Die erforderlichen Dateien für den Arm findest Du hier. Mein Ergebnis habe ich ebenfalls auf Thingiverse veröffentlicht.

Anycubic i3 Mega Firmware Upgrade

Ich musste die Firmware des Anycubic i3 Mega aktualisieren, da diese nicht out of the box mit OctoPrint sprechen wollte. Dabei gibt es da draußen ganz viele verschiedene Versionen. Am besten man probiert erstmal, ob man die Verbindung zum Drucker aus OctoPrint heraus herstellen kann. Erst wenn das nicht klappt, sollte man sich an die Firmware wagen. Immerhin kann dabei schon etwas schief gehen. Ich habe es einfach riskiert und es hat auf Anhieb funktioniert.

Dafür lädt man einfach die “update.zip” aus diesem Issue auf GitHub herunter, entpackt die Zip-Dateie und schiebt die Datei auf eine SD-Karte (direkt ins Root, nicht in einen Unterordner). Dann schaltet man den Anycubic aus und steck die SD-Karte ein. Sobald man den Drucker einschaltet, fängt dieser an zu piepen. Das klingt im ersten Moment als wäre etwas falsch, aber es ist alles richtig so! Bei mir hat das Ganze so 15-20 Sekunden gedauert. Danach startet der Drucker ganz normal wieder und die neue Firmware-Version ist installiert. Danach die Datei unbedingt wieder von der SD-Karte löschen!

In meinem Fall wurde die Version v1.4.1RC1/P2 auf v1.4.1RC2/P2 aktualisiert. Nach dem Update konnte sich OctoPrint auch sofort mit dem Drucker verbinden! Damit die Kommunikation reibungslos abläuft, müssen aber noch zwei Plugins für Anycubic installiert werden. Dafür wird OctoPrint einmal beendet (falls es noch läuft) und folgende Befehle ausgeführt:

cd ~/.octoprint/plugins
wget https://gist.githubusercontent.com/foosel/924a6518b2dea77c9a6ff1f2561b8bb7/raw/46dcd2cd651817683746772907917b72d0c201a5/strip_m110_parameter.py
wget https://gist.githubusercontent.com/foosel/77e4792921db744a157764f66d1d72a5/raw/8593ddb36e8d41a67ad9ccc01c36bb2863f5e7c2/rewrite_wait_to_busy.py