OctoPrint : Imprimez et surveillez votre imprimante 3D !

Michael V. -

Je possède depuis septembre 2016 une imprimante 3D et le plus ennuyant est de devoir préparer l’imprimante 3D pour lancer l’impression le lendemain matin. Pour pallier à cette tâche fastidieuse, il existe des tas d’outils permettant de prendre le contrôle de votre imprimante 3D à distance et de la surveiller. Et aujourd’hui je vais vous parler de la solution open-source : OctoPrint.

Qu’est-ce qu’OctoPrint ?

OctoPrint est une interface Web entièrement conçu en Python permettant de prendre le contrôle de votre imprimante pour la régler, la faire exécuter une tâche, stocker vos fichiers GCODE et les envoyer à l’imprimante. Il permet aussi de superviser l’imprimante 3D, récupérer les informations en temps réel comme : la température du lit, de l’extruder ou encore, voir l’état de l’impression avec un visuel en direct graphiquement ou depuis une Webcam. De plus le programme est entièrement modulable car il possible d’installer des plugins afin d’ajouter des alertes en temps réel ou encore des fonctionnalités de supervision comme un capteur de fin de bobine de filament.

Mais les fonctionnalités que ce logiciel propose ne s’arrêtent pas ici car il est possible de découper « slice » vos modèles 3D directement depuis l’interface Web et les envoyer en impression !

Enfin, le programme est suffisamment léger pour fonctionner sur une RaspberryPi (tout modèles confondus) ! Mais il est possible de l’installer sur tout type de machines que ce soit sous Linux, Windows ou Mac OS.

Installation

Comme d’habitude, je vais vous guider sur l’installation sous Linux. Si vous souhaitez installer sur un autre système, je vous invite à cliquer sur ce lien pour l’installation Windows et ici pour l’installation sur Mac OS. Si vous ne souhaitez pas vous embêter sur l’installation d’OctoPrint sur votre Raspberry, sachez qu’il existe une distribution toute faite disponible juste ici.

Pré-requis

Vous aurez besoin pour l’installation d’OctoPrint :

  • Une machine (ordinateur, serveur, RPi/clone) sous Linux (je ferais l’installation sous Debian)
  • Une imprimante 3D
  • Un cordon permettant de raccorder l’imprimante 3D à la machine
  • (Optionnel) Une WebCam ou une PiCamera ou pour ceux qui ont plus de moyens : une caméra IP :p

Installation de base

Dans un premier temps, on va commencer par créer un nouvel utilisateur pour OctoPrint et l’ajouter au groupe tty et dialout :

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

On ajoute les droits sudo à notre utilisateur en ajoutant la ligne suivante dans le fichier /etc/sudoers :

octoprint ALL=(ALL) NOPASSWD: ALL

Puis, on se connecte sur l’utilisateur puis on envoi cette liste de commande qui va installer les dépendances, cloner le dépôt et installer toutes les librairies Python pour OctoPrint :

sudo apt install python-pip python-dev python-setuptools python-virtualenv git libyaml-dev build-essential 
git clone https://github.com/foosel/OctoPrint.git 
cd OctoPrint 
virtualenv venv ./venv/bin/pip install pip --upgrade 
./venv/bin/python setup.py install 
mkdir ~/.octoprint

Une fois terminé, vous pouvez tapez la commande suivante qui va lancer le serveur Web afin de tester l’installation :

./venv/bin/octoprint

Mettre à jour OctoPrint

Pour mettre à jour OctoPrint, il vous suffit d’entrer les commandes suivantes dans le dossier d’OctoPrint :

git pull ./venv/bin/python setup.py clean ./venv/bin/python setup.py install

Mise en place du daemon

Dans un premier temps, on va vérifier que le chemin vers les fichiers binaires d’OctoPrint sont corrects dans les fichiers scripts/octoprint.init et scripts/octoprint.default. Le chemin doit ressembler à celui-ci (sauf si vous l’avez installé autre part sur votre système) :

DAEMON=/home/octoprint/OctoPrint/venv/bin/octoprint

Ensuite on copie le fichier octoprint.init vers /etc/init.d puis octoprint.default vers /etc/defaults puis on dit au système d’exécuter le script au démarrage :

sudo cp scripts/octoprint.init /etc/init.d/octoprint 
sudo chmod +x /etc/init.d/octoprint 
sudo cp scripts/octoprint.default /etc/default/octoprint 
sudo update-rc.d octoprint defaults

Si vous ne souhaitez pas utiliser la WebCam, l’installation est terminée ! Il ne vous reste plus qu’à passer à la partie Utilisation de cet article 😉

Mise en place de la caméra

La dernière étape de l’installation consiste à configurer une caméra pour l’utiliser avec OctoPrint. La procédure suivante n’est valable uniquement pour ceux souhaitant utiliser une Webcam ou la PiCamera. Ceux souhaitant utiliser une caméra IP ont juste besoin d’installer les paquets imagemagick libav-tools et éditer le fichier config.yaml comme expliqué un peu plus bas.

Nous allons installer d’autres dépendances système, cloner un autre dépôt Git puis compiler un bout de code :

sudo apt install subversion libjpeg8-dev imagemagick libav-tools cmake 
git clone https://github.com/jacksonliam/mjpg-streamer.git 
cd mjpg-streamer/mjpg-streamer-experimental 
export LD_LIBRARY_PATH=. 
make

Nous allons créer les deux petits scripts dont le premier qui se nommera webcam dans le dossier scripts :

#!/bin/bash 
# Start / stop streamer daemon 
case "$1" in 
    start) 
        sudo /home/themimitoof/OctoPrint/scripts/webcamDaemon >/dev/null 2>&1 &
        echo "$0: started"
        ;; 
    stop) 
        sudo pkill -x webcamDaemon 
        sudo pkill -x mjpg_streamer 
        echo "$0: stopped" 
        ;; 
    *) 
        echo "Usage: $0 {start|stop}" >&2 
        ;; 
esac

Toujours dans le même dossier, on va créer et remplir le fichier webcamDaemon avec le contenu suivant :

#!/bin/bash

MJPGSTREAMER_HOME=/home/octoprint/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 640x480 -f 10"
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

Par défaut, le port utilisé par MJPGStreamer est le numéro 8080. Si vous le souhaitez, vous pouvez le changer en éditant les deux lignes suivantes en ajoutant le petit argument -p nport:

# Remplacer ses deux lignes 
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"

# Par
echo Running ./mjpg_streamer -o "output_http.so -w ./www -p 5066" -i "$input"
LD_LIBRARY_PATH=. ./mjpg_streamer -o "output_http.so -w ./www -p 5066" -i "$input"

On rend les deux scripts exécutables donc un petit chmod +x s’impose 😉 :

chmod +x scripts/webcam scripts/webcamDaemon

Enfin, il ne nous reste plus qu’à éditer le fichier de configuration d’OctoPrint (~/.octodroid/config.yaml) et d’y ajouter le contenu suivant :

webcam:
  stream: http://<adresse_ip ou localhost>:<port par défaut (8080) ou port que vous avez choisi>/?action=stream // Si vous utilisez une caméra IP, mettez ici le lien vers le flux MJPEG
  snapshot: http://<adresse_ip ou localhost>:<port par défaut (8080) ou port que vous avez choisi>/?action=snapshot 
  ffmpeg: /usr/bin/avconv


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

Puis on démarre (ou on redémarre) le serveur OctoPrint et le tour est joué!

sudo service octoprint start

Configuration et utilisation

Après 30 minutes/1 heure d’installation, nous voilà enfin prêt à découvrir l’interface d’OctoPrint ! Lancez votre navigateur web et tapez l’adresse : http://<ip_octoprint>:5000. On nous demande dans un premier temps si l’on souhaite créer le premier utilisateur qui possédera tous les droits. Mais sachez qu’il est possible de refuser mais niveau sécurité… bah il n’y a plus rien 🙁

L’interface est relativement simple, il est possible de préchauffer le lit chauffant, l’extracteur, voir les courbes de températures, changer la position des axes et les faire retourner à leurs points par défaut, examiner le code GCode et voir l’état en direct, ajouter/supprimer des fichiers GCode/STL et envoyer l’impression très rapidement et facilement.

Dans les paramètres de configuration, nous allons modifier quelques paramètres importants. Le premier permet de dire au logiciel sur quelle interface série et le baudrate faut-il utiliser pour se connecter à l’imprimante. La majeure partie des imprimantes utilisent le baudrate 115200.

Ensuite vous devrez modifier le profil par défaut ou créer un nouveau profil pour votre imprimante avec toutes les informations techniques comme la taille d’impression, la vitesse de chaque axe, la forme de votre imprimante, etc...

Enfin, vous pouvez modifier les températures pour chaque type de matériaux et par marque de filament (par exemple dans mon cas, j’ai créé un profil spécialement pour mon PLA de chez Prima 3D).

Vous pourrez ensuite importer vos fichiers GCode et envoyer vos impressions 😉

Pour finir, j’ai cherché l’application ultime pour piloter l’imprimante depuis mon smartphone malheureusement, toutes les applications que j’ai pu tester sont plus ou moins bugué et ne permettent pas d’imprimer ou encore de voir l’état de l’impression. Néanmoins, je peux faire le malin et allumer/éteindre l’imprimante à distance depuis l’application Hue 😎

Conclusion

Malgré le fait que je n’ai trouvé aucune application qui fait le job, allumer/éteindre mon imprimante 3D et envoyer l’impression à distance sans être physiquement présent est très pratique. Cela m’évite de devoir copier les fichiers GCode sur la carte SD et d’allumer l’imprimante le matin quand le réveil est plutôt difficile. Je verrais prochainement pour intégrer l’API Philips Hue pour piloter la prise connecté de l’imprimante directement depuis l’interface Web par le biais d’un plugin ou de commandes systèmes comme nous avons pu faire pour les scripts de la Webcam. Une solution que je propose à tous les possesseurs d’imprimantes 3D 😉

Sources : octoprint.org