La fabricació additiva (o impressió 3D) és el procés de crear objectes sòlids tridimensionals a partir d'un fitxer digital. Els braços de robots industrials es poden utilitzar com a impressora 3D de 3 eixos o de 5 eixos amb RoboDK. El vídeo següent mostra una visió general de com configurar la impressió 3D amb RoboDK fora de línia: mireu el vídeo.
La impressió 3D amb robots és possible d'una de les maneres següents:
●Convertir directament programes de Codi G (fitxer NC) a programes de robot amb RoboDK, com es mostra en el projecte de mecanitzat robotitzat. La velocitat de flux de material (directiva de l'extrusor E) es calcula correctament per a cada moviment i es pot integrar en el programa generat com a esdeveniment de programa. El Codi G és un tipus de fitxer NC admès per RoboDK i també és un format admès per moltes impressores 3D. La majoria dels programes de tall (slicer) poden generar Codi G a partir d'un fitxer STL.
●Seleccioneu Utilitats➔Projecte d'impressió 3D per obrir la configuració d'impressió 3D.



Per defecte, RoboDK tradueix la directiva E com una crida a un programa anomenat Extruder i passa el valor E com a paràmetre. Seleccioneu Esdeveniments de programa per canviar aquest comportament.

El valor de l'extrusor (E) representa quanta quantitat de material cal extrudir abans de cada moviment. Aquest valor es pot utilitzar per controlar l'alimentació de l'extrusor del robot tenint en compte la velocitat del robot i la distància entre punts.
Alternativament, és possible calcular l'alimentació de l'extrusor mitjançant un postprocessador i generar el codi adequat en conseqüència. La secció següent proporciona un exemple.
Aquesta secció mostra com modificar un postprocessador de robot per calcular la velocitat de l'extrusor abans d'executar una instrucció de moviment per a la impressió 3D. Alternativament, aquestes operacions es poden fer al controlador del robot amb la crida de programa Extruder (comanda predeterminada per accionar l'extrusor).
Personalitzant un postprocessador de robot, és possible facilitar la integració d'un extrusor per a la impressió 3D abans d'enviar el programa al robot. Per dur a terme aquesta tasca, cal fer alguns càlculs i generar codi personalitzat quan el programa es genera al postprocessador del robot.
El primer pas és interceptar les crides a l'extrusor i llegir els nous valors de l'extrusor (valors E) dins de la secció RunCode del postprocessador. La secció següent processa totes les crides de programa generades per a un programa:
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)
El valor de l'Extruder (longitud/E) es desa com la variable PRINT_E_NEW en el postprocessador del robot.
Cal desencadenar una crida de funció anomenada new_move amb cada nova instrucció de moviment lineal. Podem afegir aquesta crida al començament de la comanda MoveL:
def MoveL(self, pose, joints, conf_RLF=None):
"""Add a linear movement"""
# Handle 3D printing Extruder integration
self.new_move(pose)
...
També hem d'afegir les variables següents a l'encapçalament del postprocessador per calcular els increments de l'extrusor:
# 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
Finalment, cal definir un nou procediment que generarà les ordres d'alimentació de l'extrusor adequades segons la distància entre moviments, la velocitat del robot i l'acceleració del robot. Això suposa que l'alimentació de l'extrusor està controlada per una sortida analògica específica o per una crida de programa personalitzada.
Cal afegir el codi següent abans de la definició del programa def MoveL.
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 is None or new_pose is None:
return
# Skip the first move and remember the pose
if self.PRINT_POSE_LAST is None:
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 is None 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