Impresión 3D Robótizada

La impresión 3D o fabricación aditiva es el proceso de hacer objetos sólidos tridimensionales desde un archivo digital. Los brazos robots industriales pueden ser utilizados como una impresora 3D de 3 ejes o como una impresora 3D de 5 ejes con RoboDK. El siguiente vídeo muestra una visión general de cómo configurar la impresión 3D con RoboDK fuera de línea: Ver vídeo.

La impresión 3D con los robots es posible en una de las siguientes formas:

●Convierta directamente programas de código G (archivo NC) a programas de robot con RoboDK, como se muestra con el Proyecto de mecanizado de robots. La tasa de flujo de material (directiva E de extrusora) está correctamente tenida en cuenta para cada movimiento y se puede integrar en el programa generado como un Evento del programa. El código G es un tipo de archivo del NC soportado por RoboDK y es también un formato soportado por muchas impresoras 3D. La mayoría de los softwares rebanadores pueden generar el código G dado un archivo de STL.

●Seleccione Utilidades➔Proyecto de Impresión 3D para abrir la configuración de impresión 3D. Estos ajustes son los mismos que para el Proyecto de Mecanizado Robótico, la única diferencia es que el Entrada de ruta está preajustada para imprimir objeto 3D. Seleccione Seleccionar Objeto para seleccionar el objeto en la pantalla principal y obtenga automáticamente la trayectoria de herramienta. Seleccione opciones de impresión 3D para abrir Slic3r.

De forma predeterminada, RoboDK traduce la directiva E como una llamada de programa a un programa llamado Extrusora y pasando el valor E como parámetro. Seleccione Eventos del programa para cambiar este comportamiento.

El valor de la Extrusora (E) presenta la cantidad de material que necesita ser sacado antes de cada movimiento. Este valor se puede utilizar para impulsar la alimentación de la extrusora desde el robot teniendo en cuenta la velocidad del robot y la distancia entre los puntos.

Alternativamente, es posible calcular la alimentación de la extrusora utilizando un post-procesador y generar el código apropiado en consecuencia. La siguiente sección proporciona un ejemplo.

Post-Procesador para impresión 3D robótica

Esta sección muestra cómo modificar un postprocesador de robot para calcular la velocidad de la extrusora antes de ejecutar una instrucción de movimiento para impresión 3D. Alternativamente, estas operaciones se pueden realizar en el controlador del robot con la llamada de programa Extruder (comando predeterminado para controlar la extrusora).

Personalizando un postprocesador de robot, es posible facilitar la integración de una extrusora para impresión 3D antes de enviar el programa al robot. Para lograr esta tarea, necesitamos realizar algunos cálculos y generar código personalizado cuando se genera el programa en el postprocesador del robot.

El primer paso es interceptar las llamadas a Extruder y leer los nuevos valores de Extruder (valores E) dentro de la sección RunCode del postprocesador. La siguiente sección procesa todas las llamadas de programa generadas para 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 Extruder (longitud/E) se guarda como la variable PRINT_E_NEW en el postprocesador del robot.

Necesitamos activar una llamada a la función new_move con cada nueva instrucción de movimiento lineal. Podemos añadir esta llamada al principio del comando MoveL:

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

        """Add a linear movement"""

        # Handle 3D printing Extruder integration

        self.new_move(pose)    

       ...

También debemos añadir las siguientes variables en la cabecera del postprocesador para calcular los incrementos de la extrusora:

    # 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

Finalmente, necesitamos definir un nuevo procedimiento que genere los comandos de alimentación de la extrusora adecuados según la distancia entre movimientos, la velocidad del robot y la aceleración del robot. Esto asume que la alimentación de la extrusora se controla mediante una salida analógica específica o una llamada de programa personalizada.

Necesitamos añadir el siguiente código antes de la definición 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 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