Vous êtes ici:

Menu


Stacks Image 36912
Nouveau projet raspberry après l'acquisition d'une imprimante 3D Creality Ender 5 Pro, je voulais réaliser ce tutoriel pour vous présenter les modifications que j'ai apporté cette installation.
Ces modifications ne sont pas terminées, loin de là. Je continuerais à alimenter cet article au fur et à mesure de mes découvertes.
Attention, je débute dans l'impression 3D, donc il se peut qu'il y ait des erreurs ou omissions. N'hésitez pas à me part de vos remarques.

1 But du projet

Mon imprimante 3D étant dans mon garage à un étage en dessous de mon bureau, il fallait que je trouver une solution pour piloter à distance cette machine. Je voulais aussi une interface simple pour réaliser certaines commandes sur place à côté de l'imprimante. J'ai donc choisi OctoPrint pour piloter à distance mon imprimante et OctoScreen pour réaliser une interface tactile à proximité de mon imprimante.
Mon choix du Raspberry se porte sur le PI 4 2 Go avec une carte SDRam de bonne qualité.

1.1 Les liens du projet

2 OctoPrint

Je ne vous ferais pas un tutoriel sur l'installation d'OctoPrint, vous trouverez une multitude de tutoriel sur le net. L'installation est simple et ne pose pas de difficulté particulière. je vais juste vous indiquer les paramétrages spécifiques à l'Ender 5 Pro.

2.1 Paramétrage de l'imprimante

Pendant le premier paramétrage d'octoprint, on vous demandera d'ajouter les paramètres de votre imprimante
Stacks Image 969812
Stacks Image 969823
Stacks Image 969820
Stacks Image 969817

3 OctoScreen

Avant d'installer OctoScreen, il faudra mettre à jour votre Raspberry. il faut configurer l'écran tactile de votre Raspberry. Je vous propose deux installations ci-dessous.
sudo apt update && sudo apt upgrade -y
N'oubliez pas de configurer la localisation et de changer le mot de passe par défaut. il faut configurer l'écran tactile de votre Raspberry. Je vous propose deux installations ci-dessous.

3.1 Installation d'un écran Waveshare 7 pouces tactile

Cet écran très confortable pour OctoScreen nécessite le branchement d'un port USB pour la gestion tactile. Il utilise un port HDMI. L'installation de cet écran est très facile.
Stacks Image 969529
Installation avec l'écran 7 pouces
Pour la prise en compte de cet écran, il faudra modifier le fichier /boot/config.txt. Rajoutez les lignes suivantes.
#ecran 7pouces
max_usb_current=1
hdmi_force_hotplug=1
config_hdmi_boost=10
hdmi_group=2
hdmi_mode=87
hdmi_cvt 1024 600 60 6 0 0 0
Et surtout commentez la ligne suivante.
#dtoverlay=vc4-fkms-v3d
Redémarrez le raspberry, vous devez avoir un affichage cohérent. N'oubliez pas de mettre à jour OctoPrint avec la version 1.40.

3.2 Installation d'un écran HyperPixel 4 pouces tactile

Ce petit écran de 4 pouces tactile de très bonne qualité se branche sur les ports I/0 du raspberry. Il permet d'avoir une installation compacte.
Stacks Image 969651
Pour afficher des informations sur cet écran, il faut installer un programme spécifique.
curl https://get.pimoroni.com/hyperpixel4 | bash
Il faudra choisir une option, comme j'utilise un raspberry Pi 4, on optera pour l'option 2 pour la gestion tactile.
Pick your HyperPixel 4 and Raspberry Pi combo below:
0 : Rectangular - Pi 3B+ or older
1 : Rectangular - Pi 4
2 : Rectangular - Pi 4 - Experimental Touch Fix
3 : Weirdly Square - Pi 3B+ or older
4 : Weirdly Square - Pi 4
Press Ctrl+C to cancel.

If you have problems with your install
let us know: https://github.com/pimoroni/hyperpixel4

Enter an option [0-3]:2
Ne redémarrez pas le raspberry. Modifiez le fichier /boot/config.txt. Commentez la ligne suivante.
#dtoverlay=vc4-fkms-v3d
Et ajoutez les lignes suivantes
dtoverlay=hyperpixel:rotate
display_rotate=1
Redémarrez le raspberry, normalement vous visualiser les lignes de démarrage du raspberry. Après l'installation des paquets requis pour OctoScreen (paragraphe 3.4), il faudra paramétrer l'écran tactile.

3.3 Installation du plugin Z-Bool OctoScreen

L'intérêt du plugin Z-Bool OctoScreen est de rajouter des paramètres supplémentaires pour OctoScreen. Il faut installer le plugin manuellement. Saisissez le lien suivant :
https://github.com/Z-Bolt/OctoPrint-Z-Bolt-OctoScreen/archive/master.zip
Stacks Image 969830
L'interface change avec l'installation de ce plugin.
Stacks Image 969837
Continuons avec les paramètres supplémentaires de ce plugin. Cliquez sur la clé à molette en haut à droite.
Stacks Image 969842
Les paramètres seront sauvegardés dans le fichier /home/pi/.octoprint/config.yaml dans la section zbolt_octoscreen.
    zbolt_octoscreen:
filament_in_length: '750'
filament_out_length: '800'
toolchanger: true
z_axis_inverted: false

3.3 Modification du plugin

Par défaut, nous avons le paramètre "Invert Z axis buttons on move screen" mais nous aurons besoin d'inverser les axes X et Y.
Maintenant, modifions le plugin pour rajouter l'inversion des axes X et Y. Commençons par le fichier settings.py
vi /home/pi/oprint/lib/python2.7/site-packages/octoprint_zbolt_octoscreen/settings.py
Rajoutez les lignes suivantes marquées en gras.
class ZBoltOctoScreenSettings(object):
def __init__(self, settings):
self._settings = settings
self.default_menu_structure = default_menu_structure

def get_all(self):
return {
"filament_in_length": float(self._settings.get(["filament_in_length"])),
"filament_out_length": float(self._settings.get(["filament_out_length"])),
"gcodes": self._settings.get(["gcodes"]),
"toolchanger": bool(self._settings.get(["toolchanger"])),
"z_axis_inverted": bool(self._settings.get(["z_axis_inverted"])),
"x_axis_inverted": bool(self._settings.get(["x_axis_inverted"])),
"y_axis_inverted": bool(self._settings.get(["y_axis_inverted"])),

"menu_structure": json.loads(self._settings.get(["menu_structure"])),
}

@staticmethod
def default_settings():
return dict(
filament_in_length=750,
filament_out_length=800,
toolchanger=False,
z_axis_inverted=True,
y_axis_inverted=True,
x_axis_inverted=True,

gcodes=dict(auto_bed_level="G29"),
menu_structure=default_menu_structure,
)

@staticmethod
def template_vars():
return dict(default_menu_structure=default_menu_structure)
Modifions maintenant l'interface du plugin en modifiant le fichier suivant zbolt_octoscreen_settings.jinja2.
vi /home/pi/oprint/lib/python2.7/site-packages/octoprint_zbolt_octoscreen/templates/zbolt_octoscreen_settings.jinja2
Rajoutons ces lignes après la déclaration de l'inversion de l'axe Z
                <div class="control-group">
<label class="control-label">{{ _('Invert Z axis buttons on move screen:') }}
<div class="controls">
<input type="checkbox" data-bind="checked: settings.plugins.zbolt_octoscreen.z_axis_inverted" />
</div>
</div>
<div class="control-group">
<label class="control-label">{{ _('Invert X axis buttons on move screen:') }}
<div class="controls">
<input type="checkbox" data-bind="checked: settings.plugins.zbolt_octoscreen.x_axis_inverted" />
</div>
</div>
<div class="control-group">
<label class="control-label">{{ _('Invert Y axis buttons on move screen:') }}
<div class="controls">
<input type="checkbox" data-bind="checked: settings.plugins.zbolt_octoscreen.y_axis_inverted" />
</div>
</div>

Redémarrez le serveur Octoprint et vérifiez le fonctionnement des nouveaux paramètres.
Stacks Image 969760
Mise en place des shields
Décochez tous les paramètres des axes et sauvegardez, le fichier de configuration devrait avoir ces nouveaux paramètres.
    zbolt_octoscreen:
filament_in_length: '750'
filament_out_length: '800'
x_axis_inverted: false
y_axis_inverted: false
z_axis_inverted: false
Cochez de nouveau pour avoir l'inversion des axes dans OctoScreen.

3.4 Récupération du projet OctoScreen

Nous allons installer OctoScreen, préparez les paquets requis à l'installation.
sudo apt-get install libgtk-3-0 xserver-xorg xinit x11-xserver-utils -y
Stacks Image 969980
Polices de caractères manquantes
Lors de mes tests, je me suis aperçu d'un message d'avertissement du serveur X. Il manque quelques polices de caractères. Voici les messages du fichier /var/log/Xorg.0.log
[   113.136] (WW) The directory "/usr/share/fonts/X11/cyrillic" does not exist.
[ 113.136] Entry deleted from font path.
[ 113.136] (WW) The directory "/usr/share/fonts/X11/100dpi/" does not exist.
[ 113.136] Entry deleted from font path.
[ 113.136] (WW) The directory "/usr/share/fonts/X11/75dpi/" does not exist.
[ 113.136] Entry deleted from font path.
[ 113.136] (WW) The directory "/usr/share/fonts/X11/Type1" does not exist.
[ 113.136] Entry deleted from font path.
[ 113.136] (WW) The directory "/usr/share/fonts/X11/100dpi" does not exist.
[ 113.136] Entry deleted from font path.
[ 113.136] (WW) The directory "/usr/share/fonts/X11/75dpi" does not exist.
[ 113.136] Entry deleted from font path.

Rien de méchant, mais je préfère avoir des logs clean pour vérifier d'éventuelles erreurs. Il suffit d'installer ces polices comme ceci :
sudo apt install xfonts-cyrillic xfonts-100dpi xfonts-75dpi gsfonts-x11 -y

Il n'y a plus de message d'erreurs
[  3460.585] (==) FontPath set to:
/usr/share/fonts/X11/misc,
/usr/share/fonts/X11/cyrillic,
/usr/share/fonts/X11/100dpi/:unscaled,
/usr/share/fonts/X11/75dpi/:unscaled,
/usr/share/fonts/X11/Type1,
/usr/share/fonts/X11/100dpi,
/usr/share/fonts/X11/75dpi,
built-ins
Pour l'écran Hyperpixel 4, il faudra gérer la rotation de l'écran pour le tactile. Modifiez le fichier suivant.
sudo vi /usr/share/X11/xorg.conf.d/40-libinput.conf
Ajoutez la ligne suivante indiquée en gras
Section "InputClass"
Identifier "libinput touchscreen catchall"
MatchIsTouchscreen "on"
MatchDevicePath "/dev/input/event*"
Driver "libinput"
Option "TransformationMatrix" "0 1 0 -1 0 1 0 0 1"
EndSection
Récupérez le dépôt git d'OctoScreen.
cd
git clone https://github.com/Z-Bolt/OctoScreen.git
Pour compiler, nous aurons besoin de Docker.
curl -fsSL get.docker.com -o get-docker.sh
sh get-docker.sh
Important, pour réussir la compilation, ajoutez pi au groupe docker. Reconnectez-vous pour prendre en compte cette modification.
sudo usermod -aG docker pi

3.5 Modification du projet OctoScreen

Actuellement, j'ai modifié deux écrans pour prendre en compte l'inversion des axes XYZ. Tout d'abord, l'écran move.
Stacks Image 969763
L'écran move par défaut
Modifiez le fichier suivant
vi OctoScreen/ui/move.go
Modifiez le fichier suivant dans la fonction initialize. Remplacez les lignes suivantes
        m.Grid().Attach(m.createMoveButton("X-", "move-x-.svg", octoprint.XAxis, -1), 1, 1, 1, 1)
m.Grid().Attach(m.createMoveButton("X+", "move-x+.svg", octoprint.XAxis, 1), 3, 1, 1, 1)
m.Grid().Attach(m.createMoveButton("Y+", "move-y+.svg", octoprint.YAxis, 1), 2, 0, 1, 1)
m.Grid().Attach(m.createMoveButton("Y-", "move-y-.svg", octoprint.YAxis, -1), 2, 2, 1, 1)
par
	if m.UI.Settings != nil && m.UI.Settings.XAxisInverted {
m.Grid().Attach(m.createMoveButton("X+", "move-x-.svg", octoprint.XAxis, 1), 1, 1, 1, 1)
m.Grid().Attach(m.createMoveButton("X-", "move-x+.svg", octoprint.XAxis, -1), 3, 1, 1, 1)
} else {
m.Grid().Attach(m.createMoveButton("X-", "move-x-.svg", octoprint.XAxis, -1), 1, 1, 1, 1)
m.Grid().Attach(m.createMoveButton("X+", "move-x+.svg", octoprint.XAxis, 1), 3, 1, 1, 1)
}
if m.UI.Settings != nil && m.UI.Settings.YAxisInverted {
m.Grid().Attach(m.createMoveButton("Y-", "move-y+.svg", octoprint.YAxis, -1), 2, 0, 1, 1)
m.Grid().Attach(m.createMoveButton("Y+", "move-y-.svg", octoprint.YAxis, 1), 2, 2, 1, 1)
} else {
m.Grid().Attach(m.createMoveButton("Y+", "move-y+.svg", octoprint.YAxis, 1), 2, 0, 1, 1)
m.Grid().Attach(m.createMoveButton("Y-", "move-y-.svg", octoprint.YAxis, -1), 2, 2, 1, 1)
}
On continue par l'écran bed level. Modifiez le fichier suivant
vi OctoScreen/ui/bed-level.go
Modifiez le fichier suivant dans la fonction defineLevelingPoints. Remplacez les lignes suivantes
        m.points = map[string][]float64{
"t-l": {xOffset, yMax - yOffset},
"t-r": {xMax - xOffset, yMax - yOffset},
"b-l": {xOffset, yOffset},
"b-r": {xMax - xOffset, yOffset},
}
par
	if m.UI.Settings != nil && m.UI.Settings.YAxisInverted {
if m.UI.Settings != nil && m.UI.Settings.YAxisInverted {
m.points = map[string][]float64{
"t-l": {xMax - xOffset, yOffset},
"t-r": {xOffset, yOffset},
"b-l": {xMax - xOffset, yMax - yOffset},
"b-r": {xOffset, yMax - yOffset},
}
} else {
m.points = map[string][]float64{
"t-l": {xMax - xOffset, yMax - yOffset},
"t-r": {xOffset, yMax - yOffset},
"b-l": {xMax - xOffset, yOffset},
"b-r": {xOffset, yOffset},
}
}
} else {
if m.UI.Settings != nil && m.UI.Settings.YAxisInverted {
m.points = map[string][]float64{
"t-l": {xOffset, yOffset},
"t-r": {xMax - xOffset, yOffset},
"b-l": {xMax - xOffset, yOffset},
"b-r": {xMax - xOffset, yMax - yOffset},
}
} else {
m.points = map[string][]float64{
"t-l": {xOffset, yMax - yOffset},
"t-r": {xMax - xOffset, yMax - yOffset},
"b-l": {xOffset, yOffset},
"b-r": {xMax - xOffset, yOffset},
}
}
}
Il faut faire prendre en compte les variables nouvellement créées m.UI.Settings.YAxisInverted et m.UI.Settings.YAxisInverted. Nous modifierons un fichier du projet go-octoprint inclus dans OctoScreen. Modifiez le fichier suivant.
vi OctoScreen/vendor/github.com/mcuadros/go-octoprint/zbolt.go
Modifiez la structure suivante (ligne en gras)
type GetSettingsResponse struct {
// Job contains information regarding the target of the current print job.
FilamentInLength float64 `json:"filament_in_length"`
FilamentOutLength float64 `json:"filament_out_length"`
ToolChanger bool `json:"toolchanger"`
ZAxisInverted bool `json:"z_axis_inverted"`
XAxisInverted bool `json:"x_axis_inverted"`
YAxisInverted bool `json:"y_axis_inverted"`

MenuStructure []MenuItem `json:"menu_structure"`
GCodes struct {
AutoBedLevel string `json:"auto_bed_level"`
} `json:"gcodes"`
}

3.6 Compilation et installation du projet OctoScreen

Il faut compiler tout ce petit monde, attention cela va prendre du temps car le processus va construire instance docker.
cd OctoScreen/
make build
Prenez un café, la compilation prends du temps. Si tout se passe bien, vous devriez avoir les lignes suivantes :
dpkg-genchanges  >../octoscreen_2.5-1_armhf.changes
dpkg-genchanges: info: including full source code in upload
dpkg-source --after-build OctoScreen
dpkg-buildpackage: info: full upload (original source is included)
On peut installer OctoScreen.
sudo dpkg -i build/stretch/octoscreen_2.5-1_armhf.deb
Le programme est lancé.
sudo systemctl status octoscreen
● octoscreen.service - OctoScreen
Loaded: loaded (/lib/systemd/system/octoscreen.service; enabled; vendor preset: enabled)
Active: active (running) since Wed 2020-06-10 18:17:58 CEST; 447ms ago
Process: 21687 ExecStartPost=/bin/bash /etc/octoscreen/disablescreenblank.sh 0 (code=exited, status=0/SUCCESS)
Main PID: 21658 (xinit)
Tasks: 27 (limit: 4373)
Memory: 30.0M
CGroup: /system.slice/octoscreen.service
─21658 /usr/bin/xinit /usr/bin/OctoScreen -- :0 -nolisten tcp -nocursor
─21659 /usr/lib/xorg/Xorg :0 -nolisten tcp -nocursor
└─21671 /usr/bin/OctoScreen
Il faut finaliser la configuration en adaptant la résolution de l'écran et le fichier de log.
sudo vi /etc/octoscreen/config
Ajoutez les informations pour un écran 7 pouces
# Resolution of the application, should be configured to the resolution of your
# screen, for example 800x480.
OCTOSCREEN_RESOLUTION=1024x600

# Location of file for logging (optional)
OCTOSCREEN_LOG_FILE=/var/log/octoscreen
Relancez octoscreen
sudo systemctl restart octoscreen

3 Tests

Voici l'écran d'accueil d'OctoScreen avec l'écran 7 pouces.
Stacks Image 969943
et avec l'écran 4 pouces.
Stacks Image 969975
Et une petite vidéo pour vérifier le fonctionnement des déplacements des axes XYZ en adéquation avec l'écran tactile.
00:00  /  00:00
comments powered by Disqus
 Vous êtes ici:

Nous utilisons des cookies pour nous permettre de mieux comprendre comment le site est utilisé. En continuant à utiliser ce site, vous acceptez cette politique.