Przystawka do OctoPrinta (autoconnect i klawisze pauzy/wznowienia)

[ethanak]

Na wstępie od razu uwaga: o ile prezentowane rozwiązania mechaniczne (tzn. sposoby mocowania itd.) dotyczą Anet A8, o tyle elektronika i programy są uniwersalne - wymogiem jest tylko Raspberry Pi i OctoPrint.

Zaczęło się od tego, że muszę w końcu skończyć parę robotopodobnych konstrukcji, a z racji niewielkich możliwości warsztatowych (nawet imadła nie mam gdzie przykręcić) postanowiłem kupić drukarkę 3d aby parę brakujących elementów dodrukować. Po przeanalizowaniu finansów (i przekonaniu mojej kochanej że bez drukarki życie mi niemiłe) na szafce stanęła śliczna chińska Anet A8.

Krótko potem doszedłem do wniosku, że latanie na drugi koniec mieszkania z kartą aby coś wydrukować nie jest tym, co tygrysy lubią najbardziej. Oczywiście - istnieje kilka różnych opcji, ale postanowiłem wypróbować OctoPrinta (choćby dlatego, że mam starego lapka z połamanym zawiasem który idealnie nadawał się do prób - czyli w sumie mogłem próbować bezkosztowo). Po oswojeniu się z OctoPrintem postanowiłem dokupić jakiś jednopłytkowy komputerek, bo laptop zajmuje jednak trochę zbyt dużo miejsca.

Niestety - wyjęty z szuflady NanoPi po uruchomieniu OctoPrinta (jeszcze przed podłączeniem drukarki) uprzejmie się usmażył (nie będę się nad tym rozwodził bo to nie ma nic wspólnego z tematem) - postanowiłem więc kupić Raspberry Pi.

Po paru dniach przyszedł Raspberry. Postanowiłem nie instalować OctoPi a normalnego Raspbiana i doinstalować do niego OctoPrinta. Nie wiem czy to dobry wybór - ale wolę mieć normalny system, bo przecież raspberry może słuzyć nie tylko do drukowania!

Przez kilka dni Raspberry leżał sobie na szafce w jakiejś prowizorycznej obudowie, w końcu miałem tego dość. Co prawda typowym miejscem do zamontowania RPi na Anetce jest lewa część ramy zaraz nad płytą główną - ale wydrukowałem sobie osłonę kabli osi Z, a pomysł mocowania jej do obudowy RPi uznałem za bezsensowny (niewygodny dostęp do komputerka).

Natomiast idealnym miejscem zamontowania wydał mi się wyświetlacz - z tyłu za nim jest mnóstwo miejsca, nawet cztery śruby M3 mamy do dyspozycji. Na Thingiversie znalazłem gotowca (mocowanie), na szczęście najpierw przymierzyłem... i okazało sę, że albo gniazda USB będą z niewłaściwej strony (po prawej), albo wtyczka zasilania z kablem będzie wystawać pod ramą. Postanowiłem więc zrobić własny projekt, gdzie RPi byłby przesunięty maksymalnie do góry. Projekt wyszedł całkiem nieźle (pomijając jeden błąd, naprawiony zresztą w załączonych plikach - mianowicie zapomniałem zostawić otwór na kartę pamięci). Oto on:

Montaż jest bardzo prosty - Należy po prostu przykręcić RPi do wydrukowanego mocowania za pomocą czterech śrubek M2 ze stożkowym łbem:

Następnie należy odkręcić cztery nakrętki mocujące tylną osłonę wyświetlacza, odłączyć taśmę i na wystające śruby założyć mocowanie:

Warto również zastąpić nakrętki trzymające płytę wyświetlacza po prostu podkładkami 2mm (wydrukowałem sobie takie przy okazji) - przybajmniej można będzie całość skręcić zwykłym śrubokrętem bez używania jakichś wymyślnych kluczy.

Tak zamocowany RPi został podłączony do zasilacza i działa non stop, niezależnie od drukarki. Dość szybko okazało się, że OctoPrint ma wadę: nie potrafi automatycznie podłączyć się do drukarki po jej włączeniu czy resecie. Niby drobiazg - ale niewygodny. Postanowiłem zrobić jakiś automat, który będzie to robił za mnie. Jak to powinno działać? Program powinien wykryć moment włączenia czy resetu drukarki, i wywołać funkcję "connect" z API OctoPrinta. Tyle założeń, ale jak wykryć włączenie?

Po włączeniu pojawi się przecież nowe urządzenie USB, a wykrycie takowego jest już proste; wystarczy odpowiednio oprogramować regułki w udev. Jest tylko jeden problem - co prawda demon udevd potrafi wywołać jakiś tam program, ale nusi być on wykonany jak najszybciej, przy czym oczekiwanie na wykonanie takiego programu blokuje całe działanie demona. Czyli nawet gdyby udało mi się jakoś skrócić czas działania programu - i tak zadziałałby zanim urządzenie pojawi się w systemie 😞 Teoretycznie można by było zrobić fork, w potomnym procesie poczekać parę sekund i dopiero wywołać funkcję OctoPrinta, ale wydało mi się to jakieś takie mało profesjonalne...

Postanowiłem więc zrobić inaczej. Główny program uruchamiany jest przez systemd przy starcie systemu. Przez cały czas nie robi nic, po prostu czeka na sygnał. Po jego otrzymaniu odczekuje chwilę i wywołuje octoprintowy "connect". Nic nie sprawdza - to wywołanie jest o tyle bezpieczne, że jeśli drukarka już jest do octoprinta podłączona po prostu nic się nie stanie, a próba podłączenia wyłączonej drukarki skończy się po prostu błędem i tyle.
Program wgrałem jako /usr/local/bin/watchprinter i nadałem mu prawa do wykonania. Cały kod programu jest tak krótki, że postanowiłem zamieścić go tutaj.

#!/usr/bin/env python
#coding: utf-8

import requests, json, re,  signal, time, yaml

class octonector(object):
    api = None
    def __init__(self):
        if not self.__class__.api:
            conf = yaml.safe_load(open('/home/pi/.octoprint/config.yaml'))
            self.__class__.api = conf['api']['key']
        self._enabled = False

    def enable(self):
        self._enabled = True

    def enabled(self):
        rc = self._enabled
        self._enabled = False
        return rc
        
    def doPostRequest(self,cmd,data):
        path='http://127.0.0.1:5000/api/%s' % cmd
        rc=requests.post(path, headers={
        'Host': 'localhost',
        'Content-Type': 'application/json',
        'X-Api-Key' : self.__class__.api},
        json=data)
        return rc.status_code in (204,200)
        
watcher=octonector()
        
def ena(*args):
    global watcher
    watcher.enable()
    
signal.signal(signal.SIGUSR1, ena)
            
while True:
    signal.pause()
    if watcher.enabled():
        time.sleep(5);
        try:
            watcher.doPostRequest('connection',{'command':'connect'})
        except:
            pass

Jak widać użyłem tu dwóch bibliotek, których w systemie nie ma - requests i yaml. Co prawda mógłbym skorzystać z wirtualnego śwodowiska OctoPrinta (w którym te biblioteki są zainstalowane) - postanowiłem jednak doinstalować je do systemu (szczególnie, że zarówno python-requests jak i python-yaml są w repozytorium i instaluje się je zwykłym aptem).

Teraz mogłem już przetestować działanie. Po uruchomieniu i wysłaniu do programu sygnału USR1 drukarka została podłączona do OctoPrinta. Mogłem więc zająć się zautomatyzowaniem wszystkich czynności. Na początek zgrałem swój program z systemd. W tym celu w /etc/systemd/system/ umieściłem plik watchprinter.service z zawartością:

[Unit]
Description=Autoconnect for octoprint

[Service]
Type=simple
ExecStart=/usr/local/bin/watchprinter
Restart=always
RestartSec=15

[Install]
WantedBy=multi-user.target

Po wydaniu polecenia:

sudo systemctl start watchprinter

mogłem już nie bawić się w szukanie pid-u programu - polecenie

sudo systemctl kill -s USR1 watchprinter

załatwiało to za mnie.

Tak więc nakazałem poprzez "sudo systemctl enable watchprinter" uruchamianie mojego programu przy starcie systemu - pozostało tylko automatyczne wysłanie sygnału po włączeniu drukarki.

W tym celu musiałem znaleźć identyfikatory USB podłączonej drukarki. Przy włączonej drukarce polecenie "sudo lsusb" dało następujący wynik:

Bus 001 Device 012: ID 1a86:7523 QinHeng Electronics HL-340 USB-Serial adapter
Bus 001 Device 004: ID 0424:7800 Standard Microsystems Corp.
Bus 001 Device 003: ID 0424:2514 Standard Microsystems Corp. USB 2.0 Hub
Bus 001 Device 002: ID 0424:2514 Standard Microsystems Corp. USB 2.0 Hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

Stwierdziłem, że pierwsza na liście to moja Anetka. Tak więc pozostało mi jedynie dopisać regułki udeva. Do pliku /etc/udev/rules.d/55-printer.rules wpisałem zawartość:

ACTION=="add", SUBSYSTEMS=="usb", ATTRS{idProduct}=="7523", ATTRS{idVendor}=="1a86", RUN+="/bin/systemctl kill -s USR1 watchprinter"

Jak widać, idVendor i idProduct pobrałem właśnie z informacji podanych przez lsusb.

No i po restarcie udeva mogłem już cieszyć się działającym automatem podłączającym drukarkę do OctoPrinta po jej włączeniu.

No ale cóż - apetyt rośnie w miarę jedzenia. Zamarzyły mi się dodatkowe klawisze pauzy i restartu przy druku z OctoPrinta oraz jakieś ledy sygnalizujące stan drukarki (a właściwie OctoPrinta). Zacząłem więc od przeglądu szuflady. Razem z Raspberrym kupiłem w Botlandzie wtyk do złącza GPIO (kątowy - żeby się nie pomylić przy wtykaniu) - tak więc połączenie z komputerkiem miałem z głowy. Do tego znalazłem kilka przycisków tact-switch w różnych kolorach i płytkę uniwersalną. Klika diod LED i parę rezystorów - i całą wielce skomplikowaną elektronikę miałem skompletowaną. Z zaprojektowaniem obudowy (a właściwie panela - bo pełna obudowa nie jest przewidziana) już nie było problemów. Kilka linijek w OpenSCADzie - skorzystałem z tego, że w poprzednim projekcie miałem już zwymiarowane przyciski - i gotowe. Otwory w panelu pasują do rastra płytki uniwersalnej, a wygląda tak:

Sam panel przykręcony jest czterema śrubami M2 (wkręconymi bezpośrednio w plastik) do bocznych wsporników:

 

Trzeba pamiętać, aby otwory pod ledy poprawić wiertłem 3mm (ja użyłem 3.2mm). Kolej na płytkę. Wyciąłem kawałek o wymiarach 35x32 (gdybym ciął wszystkie krawędzie wzdłuż otworów, byłoby to 35x27.5). Otwory pod śruby nawierciłem po prostu przykładając płytkę do panelu. Po przylutowaniu wszystkich elementów wystarczyło odpowiednio podgiąć nóżki od spodu płytki, aby wszystko bez potrzeby prowadzenia ścieżek połączyć według schematu:

A tak wygląda płytka przed przykręceniem do panela:

Pozostało już tylko przykręcić płytkę do panela (cztery śruby M2 z łbem stożkowym z nakrętkami) i zamocować całość na ramie Anety. W tym celu usunąłem prawą górną tulejkę dystansową między ramą a płytą wyświetlacza, i w to miejsce wsunąłem prawy wspornik. Po skręceniu i podłączeniu wtyku do GPIO całość prezentuje się tak:

Teraz zaczęła się właściwa zabawa - czyli pisanie programu. Od razu założyłem, że obsługa klawiatury i obsługa led to będą dwa oddzielne programy - odpadła zabawa z oczekiwaniem na kilka zdarzeń jednocześnie, czyli z wątkami czy procesami. Zacząłem od sygnalizacji. Zasada działania programu jest prosta: program periodycznie odpytuje OctoPrinta o stan drukowania i zależnie od tego z apala odpowiednią kombinację led. W moim przypadku są to:

• brak - octoprint wyłączony
• czerwona - drukarka wyłączona
• niebieska - drukarka włączona, nic nie robi
• niebieska + żółta - wydruk
• niebieska + czerwona - pauza.

Dodatkowo przy zmianie stanu OctoPrint sygnalizuje programowi że ma ponownie odpytać o stan. W tym celu skorzystałem z możliwości obsługi zdarzeń przez OctoPrinta - każda zmiana stanu powoduje wysłanie sygnału do programu i natychmiastowe odpytanie. Dodatkowo musiałem doinstalować bibliotekę gpio Pythona:

sudo apt install python-rpi.gpio

Program w /usr/local/bin/octoindic znów jest bardzo prosty:

#!/usr/bin/env python
#coding: utf-8

LED_Y = 40
LED_R = 38
LED_B = 36

import RPi.GPIO as GPIO
import requests, json, re,  signal, time, os

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup([LED_Y, LED_R, LED_B],GPIO.OUT);

def led(p):
    p=p.lower() if p else ''
    GPIO.output([LED_Y,LED_R, LED_B],
        ('y' in p, 'r' in p, 'b' in p))

class ledLighter(object):
    api = None
    headers={'Host':'localhost'}
    def __init__(self):
        if not self.__class__.api:
            import yaml
            conf = yaml.safe_load(open('/home/pi/.octoprint/config.yaml'))
            try:
                self.__class__.api = conf['api']['key']
                self.headers['X-Api-Key']=self.__class__.api
            except:
                pass
        self.getStatus()

    def getStatus(self):
        code = self._getStatus()
        led(code)
        return code
        
    def _getStatus(self):
        path='http://127.0.0.1:5000/api/printer?exclude=temperature,sd'
        try:
            rt=requests.get(path,headers = self.__class__.headers)
        except:
            return 'x'
        try:
            rt.raise_for_status()
        except:
            return 'r'
        return self.parseStatus(rt.content)
        
    def parseStatus(self, content):
        try:
            content = json.loads(content)['state']['flags']
        except:
            return 'ry'
        if content['paused']:
            return 'rb'
        if content['printing']:
            return 'by'
        if content['ready']:
            return 'b'
        return 'ry'
        
lt = ledLighter()

def ena(*args):
    # tu można dodać kawałek kodu reakcji na sygnał
    pass
    
signal.signal(signal.SIGUSR1, ena)

while True:
    time.sleep(15)
    lt.getStatus()

Jak widać, program sprawdza stan za każdym razem kiedy przyjdzie sygnał USR1 oraz 15 sekund po ostatnim sprawdzeniu.
Znów wpis w /etc/systemd/system/octoindic.service jest krótki:

[Unit]
Description=Led status for octoprint

[Service]
Type=simple
ExecStart=/usr/local/bin/octoindic
Restart=always
RestartSec=5
User=pi
Group=pi
[Install]
WantedBy=multi-user.target

Po wydaniu poleceń:

sudo systemctl enable octoindic
sudo systemctl start octoindic

pozostaje jedynie dokonfigurowanie OctoPrinta. W tym celu do pliku konfiguracji ~/.octoprint/config.yaml dopisujemy:

events:
  enabled: true
  subscriptions:
  - event: Startup
    command: sudo systemctl kill -s USR1 octoindic
    type: system
  - event: Shutdown
    command: sudo systemctl kill -s USR1 octoindic
    type: system
  - event: PrinterStateChanged
    command: sudo systemctl kill -s USR1 octoindic
    type: system
  - event: PrintStarted
    command: sudo systemctl kill -s USR1 octoindic
    type: system
  - event: PrintFailed
    command: sudo systemctl kill -s USR1 octoindic
    type: system
  - event: PrintDone
    command: sudo systemctl kill -s USR1 octoindic
    type: system
  - event: PrintCancelled
    command: sudo systemctl kill -s USR1 octoindic
    type: system
  - event: PrintPaused
    command: sudo systemctl kill -s USR1 octoindic
    type: system
  - event: PrintResumed
    command: sudo systemctl kill -s USR1 octoindic
    type: system

Po restarcie OctoPrinta możemy cieszyć się dziarsko świecącymi diodami 🙂

Pozostaje kwestia klawiszy - bardzo przydatnych np. przy zmianie koloru filamentu. Znów prosty program w /usr/local/bin/octopauser:

#!/usr/bin/env python
#coding: utf-8

KEY_PAUSE = 37
KEY_RESUME = 35

import RPi.GPIO as GPIO
import requests, json, re,  signal, time, os

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup([KEY_RESUME,KEY_PAUSE],GPIO.IN,pull_up_down=GPIO.PUD_UP);

class myKeys(object):
    api = None
    headers={'Host':'localhost'}
    postheaders={'Host':'localhost'}
    def __init__(self):
        self.times=[0,0]
        if not self.__class__.api:
            import yaml
            conf = yaml.safe_load(open('/home/pi/.octoprint/config.yaml'))
            try:
                self.__class__.api = conf['api']['key']
                self.__class__.headers['X-Api-Key']=self.__class__.api
                self.__class__.postheaders['X-Api-Key']=self.__class__.api
            except:
                pass

    def key_press_p(self,*args):
        if not GPIO.input(KEY_PAUSE):
            self.times[0] = time.time()
        elif time.time() - self.times[0] >= 0.2:
            self.cmdrun("pause")
            
    def key_press_r(self,*args):
        if not GPIO.input(KEY_RESUME):
            self.times[1] = time.time()
        elif time.time() - self.times[1] >= 0.2:
            self.cmdrun("resume")
        
    def doPostRequest(self,cmd,data):
        path='http://127.0.0.1:5000/api/%s' % cmd
        try:
            rc=requests.post(path,
                headers=self.__class__.postheaders,
                json=data)
        except:
            pass
        
    def cmdrun(self,cmd):
        if cmd == "pause":
            self.doPostRequest("job", {"command" : "pause","action" : "pause" });
        elif cmd == "resume":
            s = self.getStatus()
            if s == "disconnected":
                self.doPostRequest("connection",{"command":"connect"})
            elif s == "connected":
                self.doPostRequest("job", {"command" : "pause","action" : "resume" });
    
    def getStatus(self):
        path='http://127.0.0.1:5000/api/printer?exclude=temperature,sd'
        try:
            rt=requests.get(path,headers = self.__class__.headers)
        except:
            return "off"
        try:
            rt.raise_for_status()
        except:
            return "disconnected"
        return "connected"

    def arm(self):
        GPIO.add_event_detect(KEY_PAUSE, GPIO.BOTH, callback = self.key_press_p)
        GPIO.add_event_detect(KEY_RESUME, GPIO.BOTH, callback = self.key_press_r)
        
ks = myKeys()
ks.arm()

while True:
    try:
        signal.pause()
    except KeyboardInterrupt:
        break
    except:
        pass

I także krótki wpis do /etc/systemd/system/octopauser.service:

[Unit]
Description=Pause keys for octoprint

[Service]
Type=simple
ExecStart=/usr/local/bin/octopauser
Restart=always
RestartSec=5
User=pi
Group=pi
[Install]
WantedBy=multi-user.target

Po wydaniu poleceń:

sudo systemctl enable octopauser
sudo systemctl start octopauser

możemy już cieszyć się możliwością wygodnego operowania pauzą na poziomie OctoPrinta za pomocą klawiszy.

I to wszystko. Oczywiście - całą tę konstrukcję można rozbudować. Przykładowo - czujnik filamentu można dodać równolegle do klawisza pauzy, lub poświęcić jeszcze jeden pin GPIO i lekko przerobić program. Niestety - na razie nie znalazłem czujnika, który zadziała zarówno z miękkim TPU jak i przezroczystym PMMA...

Załączam komplet plików (scad, stl oraz kody programów). Octopauser.zip

Przyjemnego pauzowania i wznawiania życzy
ethanak

Edytowano Styczeń 28, 2019 przez Treker
Poprawiłem formatowanie.

[Treker (Damian Szymański)]

Właśnie zaakceptowałem Twój opis, możesz go teraz zgłosić do akcji rabatowej umieszczając link w temacie zbiorczym. Dziękuję za przedstawienie ciekawego projektu, zachęcam do prezentowania kolejnych DIY oraz aktywności na naszym forum 🙂

[msalamon]

Podoba mi się, zwłaszacza, że przymierzam się do OctoPrinta w swojej drukarce 🙂