Plug-Ins für OctoPrint - Fortschritt auslesen und M-Befehl senden

Hallo erstmal

Ich hab die letzten Tage ein wenig rumgebastelt und eine schöne LED Beleuchtung in meinem Drucker installiert. Nachdem ich dann alles mit meinem Pi etc verkabelt habe, stand ich dort und dachte mir: jetzt wäre es ja prinzipiell noch ziemlich geil, wenn der Pi automatisch nach Fortschritt das Licht anpassen würde...

Genutzt wird aktuell das Octoprint Plugin "LED-Strip Control" - dieses arbeitet mit dem M150 Befehl - M150 R U B gibt "weißes" Licht, also alle 3 Farben.
Mein Gedanke war nun also, und Testweise Manuell auch schon gemacht:
0% - Druck Start - M150 R
10% - M150 R U51
20% - M150 R U102
30% - M150 R U153
40% - M150 R U204
50% - M150 R U
60% - M150 R204 U
70% - M150 R153 U
80% - M150 R102 U
90% - M150 R51 U
100% - Druck Ende - M150 U

Ich kann mir vorstellen, dass das eigtl überhaupt kein großer Akt ist... "Read(printprogress) - if == 10 send M150 R U51" - so frei nach der Art
Allerdings habe ich mit Python und speziell Octoprint Plugins noch nie was am Hut gehabt. Aktuell arbeite ich mich ein wenig in C und Arduinos ein, was auch gut klappt.
Somit -
Frage Nr 1: Hat jemand ein gutes Tutorial womit man da fix rein kommt, um sowas kleines zu schreiben und draufzuspielen?
Frage Nr 2: Hat ggf jemand schon solch ein Plugin geschrieben und installiert und wäre bereit, das zu teilen? Oder hab ich solch ein Plugin einfach nicht gefunden?

Ich bezweifle, dass iwer Lust hat das schnell zusammenzubasteln und online zu stellen, falls doch... Wäre ich dafür auch sehr dankbar

Sollte es jegliche Alternativen geben, bin ich dafür natürlich offen!

Besten Dank für jegliche Hinweise und Antworten im voraus!

1-mal bearbeitet. Zuletzt am 07.06.17 09:15.

---

Alle Angaben ohne Gewähr

Vielleicht gefällt Dir das hier:
[github.com]

Herzl. Grüße

Hi AlterBastler,

auf den ersten Blick sah das sehr genial aus - allerdings ist das in Kombination mit einem Arduino nur möglich.
Ich hab inzw so viel unten in dem Delta verbaut, dass ich da sogar nur schwer nen Arduino Mini reinkriegen würde...

Somit bleib ich wieder beim alten Konzept, trotzdem vielen Dank!

---

Alle Angaben ohne Gewähr

Das Teil macht genau das was Du willst: Eventgesteuert Textbefehle an die USB-Schnittstelle senden.
Schau mal in den Quelltext. Du musst die Befehle für den Arduino nur durch Deine G-Codes ersetzen.

Herzl. Grüße

Er soll ja aber eventgesteuert die Textbefehle >im< Octoprint ins Terminal senden - womit dann entsprechend über M150 die GPIOs angesteuert werden.
werd mir heut abend mal den Quelltext anschauen, ggf kann ich das modifizieren - wenns nicht zu unverständlich oder schwer ist :/

---

Alle Angaben ohne Gewähr

Quote
Terri
Er soll ja aber eventgesteuert die Textbefehle >im< Octoprint ins Terminal senden - womit dann entsprechend über M150 die GPIOs angesteuert werden.

Das geht dann auch ohne Umweg über GCodes: [tutorials-raspberrypi.de]

Herzl. Grüße

Okay - zum einen seh ich beim Durchblättern des Tutorials nichts über Gcodes - ich seh einen fertigen Python code, allerdings für die einzelnen LEDs gedacht.
Kurzum: Es gibt ja zwei (wahrscheinlcih mehr?) Arten von LED Bändern - einmal die mit Vorwiderständen ohne ICs (12/5V , R G B Anschluss) und einmal die mit ICs (12/5V, CK SI GND o.A. Schreibweisen)
Ich nutze die 12V R G B Variante - ergo kein Lauflicht realisierbar sondern nur Farbwechsel. Stellt auch keinerlei Problem dar.

Aus dem Tutorial oder dem Code erschließt sich mir aber nicht, wie ich solch eine Funktion nutzen kann.

Obendrein weiß ich auch (noch) nicht, ob die Gcodes "durch" das Terminal vom OctoPi laufen. Kanns mir vorstellen, weiß es aber noch nicht - getestet hab ichs auch noch nicht. Ist alles grad in der Abschlussphase.
Aber selbst wenn, müsste ich für jeden Druck manuell in den Gcode und dort etwa alle 10% schätzen und die Zeilen eintragen - deutlich effizienter ist da die Lösung, den Druckfortschritt aus OctoPi abzufragen und bei zutreffendem %Satz den M150 Befehl zu senden. Ich gehe zumindest davon aus, dass ja irgendwo im Octopi dieser Wert intern berechnet wird und somit auch abgefragt werden kann.

E: Sollte ich dich jetzt irgendwo missverstehen tut es mir Leid, wie gesagt, entweder bin ich blind oder unfähig, dass da zu sehen. Danke jedenfalls bisher für deine Hilfe!

1-mal bearbeitet. Zuletzt am 08.06.17 11:02.

---

Alle Angaben ohne Gewähr

War von mir nur als Lösungsansatz gedacht, nicht als Plug and Play.
[docs.octoprint.org]
Den Druckfortschritt z.B. über ZChange ermitteln.
Das Tutorial ist auch gut: [docs.octoprint.org]
Alle benötigten Techniken werden hier verwendet, deshalb gut als Vorlage:
[github.com]
In "issueCommand(..)" z.B. die GPIO-Pins direkt ansprechen. Für den Raspi gibt es Anleitungen für alle möglichen Arten von LEDS.

Herzl. Grüße

Okay.. an der Front komm ich noch nicht wirklich weiter. Bei der Eventsteuerung gibt es war den Layerchange, aber nicht den Process % oder sonstiges.

Fraglich ist immer noch, ob sowas überhaupt iwie in Octoprint vorliegt oder ob man so etwas selbst kreieren muss...

Eine weitere Möglichkeit die sich aufgetan hat:
Aktuell slice ich noch über Cura. Ich habe mal frecherweise einen 10 Layer Gcode erzeugt (rechteck) und dort am Anfang jeder Zeile eingefügt: M150 R ; M150 R U51 etc etc bis am Ende M150 U
Ergebnis: einwandfrei.

Jetzt ist die Frage, ob man hier einen neuen Gcode bei Start/End Gcodes mit einfügen kann, der automatisch die Max_Layer des Druckteils ermittelt, und dann entsprechend x0.1 => M150 R U51 ; x0.2 => M150 R U102 ; ... x0.5 M150 R U ; x0.6 M150 R204 U; ... x1 = M150 U
Oder alternativ natürlich bei Octoprint...

---

Alle Angaben ohne Gewähr

geht so nicht: [github.com]
aber so: [github.com]

Herzl. Grüße

#Name: ShowLayer
#Info: Shows the actual layer on the Ulticontroller
#Depend: GCode
#Type: postprocess

__copyright__ = "Copyright (C) 2013 Dominic von Bergen - Released under terms of the AGPLv3 License"
import re

def getLayerNumber(line, default = None):
	number = 0;
	#Remove Carrage Return in String
	line = line.replace("\n", "")
	#Extract number
	number =  line.split(':')[1]
	
	if number is None:
		return default
	try:
		return number
	except:
		return default

with open(filename, "r") as f:
	lines = f.readlines()

LayerHasLayerCountNumber = 0;
LayerCount = 0;
ActualLayer = 0;
ActualObject=0;

with open(filename, "w") as f:
	for line in lines:
		if line.startswith(';LAYER:'):
			if LayerHasLayerCountNumber == 0:
				LayerHasLayerCountNumber = 1
				LayerCount = LayerCount + 1
		else:
			LayerHasLayerCountNumber = 0;
			
	LayerCount = str(LayerCount - 1)
	
	for line in lines:
		f.write(line)
		#print the actual layer
		if line.startswith(';LAYER:'):
			ActualLayer = getLayerNumber(line,None)
			#+1 because the LayerNumber starts with 0
			ActualLayer = int(ActualLayer)
			ActualLayer = ActualLayer + 1
			if ActualLayer <= int(LayerCount):
				ActualLayer = str(ActualLayer)
f.write("M117 Layer " + ActualLayer + " of " + LayerCount + "\n")

Das ist jetzt ja der Code...
Den f.write Befehl am Ende brauche ich ja gar nicht.
Wenn ich den Code richtig verstehe, müsste ich am Ende nur folgendes hinzufügen:

If "ActualLayer == 0"
      M150 R
If "ActualLayer == LayerCount*0.1"
       M150 R U51
If "ActualLayer == LayerCount*0.2"
       M150 R U102
(...)
If "ActualLayer == LayerCount"
      M150 U

etc etc
Das kann ja ruhig um 1-2 Layer abweichen, zumal Python ja abrundet wenn ich das richtig gesehen habe.
Aber genau damit würde er doch das machen, was ich will, oder?
Das als StartGcode in Cura einbauen oder muss das in der Machine.json hinterlegt werden? :/

---

Alle Angaben ohne Gewähr

Der f.write Befehl ist gerade die Stelle, an der der G-Code eingefügt wird.
Du ersetzt M117 durch M150 und berechnest Deine Parameter aus den Werten.
Vielleicht so ähnlich:

if ActualLayer == 0:
      ActualLayer = "R"
elif ActualLayer < int(LayerCount):
      ActualLayer = "R U"+str(ActualLayer*51)
else:
      ActualLayher = "U
f.write("M150 " + ActualLayer + "\n")

Ich verstehe ja nicht genau, was Du willst...

Herzl. Grüße

P.S. das ist ein Postprocess-Script, keine Ahnung wo genau das in Cura eingefügt wird.

1-mal bearbeitet. Zuletzt am 13.06.17 10:44.

Damit kommen wir der Sache auf jedenfall näher
Wenn ich das doch richtig verstanden habe, ermittelt im Original Code die Variable "LayerCount" die Maximale Layeranzahl, während "ActualLayer" die aktuelle Layer zählt. Somit wird bei f.write ausgegeben "ActualLayer von LayerCount"

Das ist im Prinzip genau das, was ich brauche. Allerdings geschrieben im GCode, so dass es der RaspPi sendet, da die Lichtsteuerung am RaspPi hängt.

Mein Ziel nun:
Ein Farbverlauf der LEDs von Rot über Gelb nach Grün nach Druckfortschritt.
Zwar gilt nicht % Fortschritt == Layer Height, speziell nicht bei Pyramiden o.Ä., aber das ist erst mal irrelevant. Fakt ist jedoch: Je näher wir der Maximalen Layeranzahl kommen, desto näher sind wir am fertigen Druckteil.
Geplant ist das ganze in 10% Schritten.

Da ich nun nicht jeden GCode abklappern will und alles Manuell einfügen will, möchte ich gerne das ganze umgehen. Wie gesagt, per Druckfortschritt lässt sich das bisher noch nicht realisieren
(Grundgedanke: RaspPi greift über Plugin auf den Druckfortschrittsbalken zu und schickt bei 10% Fortschritt M150 Befehl, bei 20% etc.)

Somit ist dieser Ansatz nun:
Cura schreibt den Gcode und zählt nun "LayerCount" - damit werden die Maximalen Layer meines Druckteils ermittelt. Nun geht Cura die Layer nochmals durch in der nächsten Schleife. Erreicht er nun Layer:1, schreibt er "Layer ActualLayer von LayerCount" ; also "Layer 1 von 10" wenn ActualLayer = 1 und LayerCount = 10 ist.
(Ob das nun 100%ig hier stimmig ist in meinem Beispiel erst mal irrelevant, Cura zählt ja wohl mit Layer:0, aber wie gesagt, erst mal nur das Grundprinzip verdeutlicht)

Anstatt nun allerdings alle Layer auszugeben, soll die if-Schleife nur abfragen: "If ActualLayer == Layercount*0.1" - Wenn die ActualLayer == 10% von LayerCount ist... f.write("M150 R U51")

Ich versuche es mal an Zwei Beispielen fest zu machen:
Beispiel 1: Druckteil mit Layerhöhe 199 (Drucker beginnt bei layer 0, somit 200 Layer)
Als allererstes gilt: If(ActualLayer==0" f.write("M150 R") - Wir beginnen und starten mit Rot.
Layer 1 - 18 passiert nichts. Die nächste Abfrage lautet: If(ActualLayer==LayerCount*0.1) - zu Deutsch - Wenn ActualLayer = 10% von LayerCount
199*0.1 = 19,9, abgerundet 19 - Also bei Layer 19 tritt der Fall ein, somit: f.write("M150 R U51")

Layer:0
if(ActualLayer == 0)
f.write("M150 R")
...
Layer:19
if(ActualLayer == LayerCount*0.1)
f.write("M150 R U51")
...
Layer:39
if(ActualLayer == LayerCount*0.2)
f.write("M150 R U102")
...
...
Layer:99
if(ActualLayer == LayerCount*0.5)
f.write("M150 R U")
...
...
Layer 179
if(ActualLayer == LayerCount*0.9)
f.write("M150 R51 U")
...
Layer 199
if(ActualLayer == LayerCount)
f.write("M150 U")

Beispiel 2:
Druckteil mit Layerhöhe 3694

//Layer:0
if(ActualLayer == 0)
f.write("M150 R")
...
//Layer:369
if(ActualLayer == LayerCount*0.1)
f.write("M150 R U51")
...
//Layer:738
if(ActualLayer == LayerCount*0.2)
f.write("M150 R U102")
...
...
//Layer:1847
if(ActualLayer == LayerCount*0.5)
f.write("M150 R U")
...
...
//Layer:3324
if(ActualLayer == LayerCount*0.9)
f.write("M150 R51 U")
...
//Layer:3694
if(ActualLayer == LayerCount)
f.write("M150 U")

Somit würde Cura beim Gcode erzeugen automatisch unter die Layer das schreiben - so wie ichs brauche.

Ich hoffe, ich hab es nun halbwegs verständlich beschrieben, ich bin selbst 3x durcheinander gekommen und hab den Text noch mal umformuliert. Ich weiß, warum ich nicht informatiker geworden bin

---

Alle Angaben ohne Gewähr

Ich verstehe nicht, wie die Parameter den Prozentzahlen zugeordnet werden bzw. was diese besagen.
Anregung dazu:

...
Colors = ["R","R U51","R U102",...,...,...]
...
LastIndex = Index
Index = int(round(ActualLayer*len(Colors)/LayerCount))
...
if Index <> LastIndex:
  f.write("M150 " + Colors[Index] + "\n")

Herzl. Grüße

Edit: Sorry, war natürlich falsch.

1-mal bearbeitet. Zuletzt am 13.06.17 13:00.

Okay - Die werden händisch von mir dann entsprechend zugeordnet.
Durch das Plugin wird ja per Gcode "M150" der RaspPi angesprochen. M150 R U B ist weiß, M150 R ist Rot, M150 U ist Grün, B Blau, R U Gelb etc etc. - durch M150 R U51 lasse ich langsam das Grün zum Rot hinzugeben, U102, U153, U204, U255 (oder auch nur U) und dann das Rot rausnehmen ab 50%, M150 R204 U; M150 R153 U; M150 R102 U; M150 R51 U und M150 U bei 100%

Somit soll Cura nur abfragen:
"Gcode generiert - Maximale Layeranzahl?" - 199
Gcode Abfrage - 0% der Max-Layeranzahl? - 0
Gcode einfügen bei 0% => M150 R
Gcode Abfrage - 10% der Max-Layeranzahl? - 19
Gcode einfügen bei 10% => M150 R U51
Gcode Abfrage - 20% der Max-Layeranzahl? - 38
Gcode einfügen bei 20% => M150 R U102
usw usw

D.h. die M150 Befehle trage ich einmalig manuell in das PostScript ein, er schreibt sie mir ja dann automatisch in jeden Gcode mit rein.

Zumindest hab ich das jetzt so verstanden

---

Alle Angaben ohne Gewähr