Roboter-3D-Druckprojekt

Die Additive Fertigung (oder der 3D-Druck) ist ein Verfahren zur Herstellung dreidimensionaler fester Objekte auf der Grundlage einer digitalen Datei. Industrieroboterarme können mit RoboDK als 3-Achsen- oder 5-Achsen-3D-Drucker eingesetzt werden. Das folgende Video bietet einen Überblick darüber, wie Sie den 3D-Druck mit RoboDK offline einrichten: Video ansehen.

Der 3D-Druck oder die additive Fertigung ist der Herstellungsprozess dreidimensionaler fester Objekte aus einer digitalen Datei. Industrieroboterarme können hierzu als 3-Achs-3D-Drucker oder als 5-Achs-3D-Drucker mit RoboDK verwendet werden. Das folgende Video zeigt eine Übersicht über das Einrichten des 3D-Drucks mit RoboDK offline: Video anschauen.

3D-Druck mit Robotern ist auf eine der folgenden Arten möglich:

●Konvertieren Sie G-Code-Programme (NC-Datei) mit RoboDK direkt in Roboterprogramme, wie im Roboterbearbeitungsprojekt gezeigt. Die Materialflussrate (Extruder-Direktive E) wird für jede Bewegung korrekt berechnet und kann als Programm-Ereignis in das generierte Programm integriert werden. G-Code ist ein von RoboDK unterstützter NC-Dateityp und zugleich ein Format, das von vielen 3D-Druckern unterstützt wird. Die meisten Slicer-Programme können aus einer STL-Datei G-Code erzeugen.

Robot Machining - Bild 45

●Wählen Sie Dienstprogramme➔3D-Druckprojekt, um die 3D-Druckeinstellungen zu öffnen. Anmerkung: Diese Einstellungen sind mit denen eines Projekts Roboterbearbeitung identisch. Der einzige Unterschied besteht darin, dass die Bahn-Eingabe als 3D-Druckobjekt voreingestellt ist. Wählen Sie Objekt auswählen, um das Objekt auf dem Hauptbildschirm auszuwählen und automatisch den Werkzeugweg zu erhalten. Wählen Sie 3D-Druckoptionen, um Slic3r zu öffnen.

Robot Machining - Bild 46

Robot Machining - Bild 47

Standardmäßig übersetzt RoboDK die E-Direktive als Programmaufruf in ein Programm namens Extruder und übergibt den E-Wert als Parameter. Wählen Sie Programm-Ereignisse, um dieses Verhalten zu ändern.

Robot Machining - Bild 48

Der Extruder-Wert (E) gibt an, wie viel Material vor jeder Bewegung extrudiert werden muss. Dieser Wert kann verwendet werden, um die Extruderzufuhr vom Roboter, abhängig von Robotergeschwindigkeit und Abstand der Punkte, zu steuern.

Alternativ ist es möglich, die Extruderzufuhr mit einem Postprozessor zu berechnen und entsprechenden Code zu generieren. Der folgende Abschnitt enthält ein Beispiel.

Postprozessor für den Roboter-3D-Druck

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