Hinweis: Einige Postprozessoren, wie beispielsweise der ABB RAPID IRC5, der KUKA KRC2 und der Comau-Postprozessor, setzen diese empfohlenen Änderungen standardmäßig um.
Durch die Anpassung eines Roboter-Postprozessors lässt sich die Integration eines Extruders für den 3D-Druck vereinfachen, bevor das Programm an den Roboter gesendet wird. Um diese Aufgabe zu bewältigen, müssen wir einige Berechnungen durchführen und bei der Erstellung des Programms im Roboter-Postprozessor angepassten Code ausgeben.
In diesem Abschnitt wird gezeigt, wie ein Roboter-Postprozessor so angepasst werden kann, dass er die Geschwindigkeit des Extruders berechnet, bevor ein Befehl für die Bewegung zum 3D-Druck ausgeführt wird. Alternativ können diese Vorgänge auch auf der Robotersteuerung mithilfe des Programmaufrufs „Extruder“ (Standardbefehl zum Ansteuern des Extruders) durchgeführt werden.
Dieser Abschnitt zeigt, wie ein Roboter-Postprozessor angepasst werden kann, um die Geschwindigkeit des Extruders vor der Ausführung einer Bewegungsanweisung für den 3D-Druck zu berechnen. Alternativ können diese Operationen auf der Robotersteuerung mit dem Programmaufruf Extruder durchgeführt werden (Standardbefehl zur Ansteuerung des Extruders). Durch die Anpassung eines Roboter-Postprozessors lässt sich die Integration eines Extruders für den 3D-Druck vereinfachen, bevor das Programm an den Roboter gesendet wird. Dazu müssen einige Berechnungen durchgeführt und angepasster Code ausgegeben werden, wenn das Programm im Roboter-Postprozessor erstellt wird. Hinweis: Einige Postprozessoren, wie z. B. ABB RAPID IRC5, KUKA KRC2 und der Comau-Postprozessor, implementieren diese empfohlenen Änderungen standardmäßig.
Der erste Schritt besteht darin, die Extruder-Aufrufe abzufangen und die neuen Extruder-Werte (E-Werte) im Abschnitt RunCode des Postprozessors zu lesen. Der folgende Abschnitt verarbeitet alle für ein Programm erstellten Programmaufrufe:
def RunCode(self, code, is_function_call = False):
if is_function_call:
if code.startswith("Extruder("):
# Intercept the extruder command.
# if the program call is Extruder(123.56)
# we extract the number as a string
# and convert it to a number
self.PRINT_E_NEW = float(code[9:-1])
# Skip the program call generation
return
else:
self.addline(code + "()")
else:
# Output program code
self.addline(code)
Wir müssen den folgenden Code vor der Programmdefinition „def MoveL“ einfügen.
Abschließend müssen wir eine neue Prozedur definieren, die entsprechend dem Abstand zwischen den Bewegungen, der Geschwindigkeit des Roboters und der Roboterbeschleunigung geeignete Befehle für den Extrudervorschub erstellt. Dabei wird davon ausgegangen, dass der Extrudervorschub über einen bestimmten Analogausgang oder ein individuell angepasstes Programm gesteuert wird.
def MoveL(self, pose, joints, conf_RLF=None):
"""Add a linear movement"""
# Handle 3D printing Extruder integration
self.new_move(pose)
...
# 3D Printing Extruder Setup Parameters:
PRINT_E_AO = 5 # Analog Output ID to command the extruder flow
PRINT_SPEED_2_SIGNAL = 0.10 # Ratio to convert the speed/flow to an analog output signal
PRINT_FLOW_MAX_SIGNAL = 24 # Maximum signal to provide to the Extruder
PRINT_ACCEL_MMSS = -1 # Acceleration, -1 assumes constant speed if we use rounding/blending
Außerdem müssen wir die folgenden Variablen in den Kopf des Postprozessors einfügen, um die Extruder-Inkremente zu berechnen:
# Internal 3D Printing Parameters
PRINT_POSE_LAST = None # Last pose printed
Der Extruder-Wert (Länge/E) wird im Roboter-Postprozessor als Variable „PRINT_E_NEW“ gespeichert.
Der Extruder-Wert wird als NEW_E_LENGTH-Variable gespeichert. Anschließend muss man ein neues Verfahren definieren, das Extruder-Vorschubbefehle entsprechend dem Abstand zwischen den Bewegungen, der Robotergeschwindigkeit und der Roboterbeschleunigung erzeugt. Dies setzt voraus, dass die Extruderzufuhr durch eine spezifische analoge Ausgabe von der Robotersteuerung (in diesem Beispiel den analogen Ausgang Nummer 5) angetrieben wird
PRINT_E_LAST = 0 # Last Extruder length
PRINT_E_NEW = None # New Extruder Length
PRINT_LAST_SIGNAL = None # Last extruder signal
def calculate_time(self, distance, Vmax, Amax=-1):
"""Calculate the time to move a distance with Amax acceleration and Vmax speed"""
if Amax < 0:
# Assume constant speed (appropriate smoothing/rounding parameter must be set)
Ttot = distance/Vmax
else:
# Assume we accelerate and decelerate
tacc = Vmax/Amax;
Xacc = 0.5*Amax*tacc*tacc;
if distance <= 2*Xacc:
# Vmax is not reached
tacc = sqrt(distance/Amax)
Ttot = tacc*2
else:
# Vmax is reached
Xvmax = distance - 2*Xacc
Tvmax = Xvmax/Vmax
Ttot = 2*tacc + Tvmax
return Ttot
def new_move(self, new_pose):
"""Implement the action on the extruder for 3D printing, if applicable"""
if self.PRINT_E_NEW isNone or new_pose is None:
return
# Skip the first move and remember the pose
if self.PRINT_POSE_LAST isNone:
self.PRINT_POSE_LAST = new_pose
return
# Calculate the increase of material for the next movement
add_material = self.PRINT_E_NEW - self.PRINT_E_LAST
self.PRINT_E_LAST = self.PRINT_E_NEW
# Calculate the robot speed and Extruder signal
extruder_signal = 0
if add_material > 0:
distance_mm = norm(subs3(self.PRINT_POSE_LAST.Pos(), new_pose.Pos()))
# Calculate movement time in seconds
time_s = self.calculate_time(distance_mm, self.SPEED_MMS, self.PRINT_ACCEL_MMSS)
# Avoid division by 0
if time_s > 0:
# This may look redundant but it allows you to account for accelerations and we can apply small speed adjustments
speed_mms = distance_mm / time_s
# Calculate the extruder speed in RPM*Ratio (PRINT_SPEED_2_SIGNAL)
extruder_signal = speed_mms * self.PRINT_SPEED_2_SIGNAL
# Make sure the signal is within the accepted values
extruder_signal = max(0,min(self.PRINT_FLOW_MAX_SIGNAL, extruder_signal))
# Update the extruder speed when required
if self.PRINT_LAST_SIGNAL isNone or abs(extruder_signal - self.PRINT_LAST_SIGNAL) > 1e-6:
self.PRINT_LAST_SIGNAL = extruder_signal
Abschließend muss ein neues Verfahren definiert werden, das entsprechend dem Abstand zwischen den Bewegungen, der Robotergeschwindigkeit und der Roboterbeschleunigung geeignete Extruder-Vorschubbefehle erzeugt. Dies setzt voraus, dass die Extruderzufuhr durch einen bestimmten analogen Ausgang oder einen angepassten Programmaufruf angesteuert wird. Der folgende Code muss vor der Programmdefinition def MoveL hinzugefügt werden. Wichtig: Die Verwendung eines Rundungswerts beim Programmieren des Roboters in RoboDK hilft, eine konstante Geschwindigkeit beizubehalten und den Einfluss der Beschleunigung zu minimieren. In diesem Fall kann die Zeit als Abstand/Geschwindigkeit berechnet werden.
Mit jeder neuen linearen Bewegungsanweisung muss ein Funktionsaufruf namens new_move ausgelöst werden. Dieser Aufruf kann am Anfang des MoveL-Befehls hinzugefügt werden: (move to after the sentence about PRINT_E_NEW)
# Use the built-in setDO function to set an analog output
self.setDO(self.PRINT_E_AO, "%.3f" % extruder_signal)
# Alternatively, provoke a program call and handle the integration with the robot controller
#self.addline('ExtruderSpeed(%.3f)' % extruder_signal)
# Remember the last pose
self.PRINT_POSE_LAST = new_pose