Questa sezione mostra come modificare un post processore robot per calcolare la velocità dell’estrusore prima di eseguire un’istruzione di movimento per la stampa 3D. In alternativa, queste operazioni possono essere effettuate sul controller del robot con la chiamata di programma Extruder (comando predefinito per pilotare l’estrusore).

Personalizzando un post processore robot, è possibile semplificare l'integrazione di un estrusore per la stampa 3D prima di inviare il programma al robot. Per svolgere questo compito, dobbiamo eseguire alcuni calcoli e generare codice personalizzato quando il programma viene generato nel post processore del robot.

Nota: Alcuni post processori, come quelli per ABB RAPID IRC5, KUKA KRC2 e Comau, implementano queste modifiche consigliate per impostazione predefinita.

Il primo passo è intercettare le chiamate Extruder e leggere i nuovi valori Extruder (valori E) all’interno della sezione RunCode del post processore. La sezione seguente elabora tutte le chiamate di programma generate per un programma:

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)

Il valore Extruder (lunghezza/E) viene salvato nella variabile PRINT_E_NEW nel post processore del robot.

Dobbiamo attivare una chiamata di funzione denominata new_move ad ogni nuova istruzione di movimento lineare. Possiamo aggiungere questa chiamata all’inizio del comando MoveL:

def MoveL(self, pose, joints, conf_RLF=None):

"""Add a linear movement"""

# Handle 3D printing Extruder integration

self.new_move(pose)

...

Dobbiamo inoltre aggiungere le seguenti variabili nell'intestazione del post processore per calcolare gli incrementi dell'estrusore:

# 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

# Internal 3D Printing Parameters

PRINT_POSE_LAST = None # Last pose printed

PRINT_E_LAST = 0 # Last Extruder length

PRINT_E_NEW = None # New Extruder Length

PRINT_LAST_SIGNAL = None # Last extruder signal

Infine, dobbiamo definire una nuova procedura che generi i comandi appropriati per il feed dell'estrusore in base alla distanza tra i movimenti, alla velocità del robot e all'accelerazione del robot. Questo presuppone che il feed dell'estrusore sia pilotato da una specifica uscita analogica o da una chiamata di programma personalizzata.

Dobbiamo aggiungere il seguente codice prima della definizione del programma def MoveL.

Importante: L’utilizzo di un valore di raccordo durante la programmazione del robot in RoboDK aiuta a mantenere una velocità costante e a minimizzare il comportamento dell’accelerazione. In quel caso, il tempo può essere calcolato come distanza/velocità.

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

# 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

Post Processori per stampanti 3D