Projeto de impressão 3D com robôs

A manufatura aditiva (ou impressão 3D) é o processo de fabricação de objetos sólidos tridimensionais a partir de um arquivo digital. Os robôs industriais podem ser usados como uma impressora 3D de 3 ou 5 eixos com o RoboDK. O vídeo a seguir mostra uma visão geral de como configurar a impressão 3D com o RoboDK off-line: assista ao vídeo.

A impressão 3D com robôs é possível de uma das seguintes maneiras:

●Converta diretamente programas de código G (arquivo NC) em programas de robô com o RoboDK, como mostrado no projeto de usinagem com robôs. A taxa de fluxo de material (diretriz E da extrusora) é calculada corretamente para cada movimento e pode ser integrada ao programa gerado como um evento de programa. O código G é um tipo de arquivo NC suportado pelo RoboDK e é um formato suportado por muitas impressoras 3D. A maioria dos softwares de fatiamento pode gerar o código G a partir de um arquivo STL.

●Selecione Utilitários➔ Projeto de Impressão 3D para abrir as configurações de impressão 3D.

Por padrão, o RoboDK traduz a diretiva E como uma chamada de programa para um programa chamado Extruder e passa o valor E como um parâmetro. Selecione Eventos de programa para alterar esse comportamento.

O valor da extrusora (E) representa a quantidade de material que precisa ser extrudado antes de cada movimento. Esse valor pode ser usado para acionar a alimentação da extrusora do robô, levando em conta a velocidade do robô e a distância entre os pontos.

Como alternativa, é possível calcular a alimentação da extrusora usando um pós-processador e gerar o código apropriado de acordo. A seção a seguir apresenta um exemplo.

Pós-processador para impressão 3D com robôs

Esta seção mostra como modificar um pós-processador de robô para calcular a velocidade da extrusora antes de executar uma instrução de movimento para impressão 3D. Como alternativa, essas operações podem ser feitas no controlador do robô com a chamada do programa Extruder (comando padrão para acionar a extrusora).

Ao personalizar um pós-processador de robô, é possível facilitar a integração de uma extrusora para impressão 3D antes de enviar o programa para o robô. Para realizar essa tarefa, precisamos fazer alguns cálculos e gerar um código personalizado quando o programa for gerado no pós-processador do robô.

A primeira etapa é interceptar as chamadas da extrusora e ler os novos valores da extrusora (valores E) dentro da seção RunCode no pós-processador. A seção a seguir processa todas as chamadas de programa geradas para um programa:

    def RunCode(self, code, is_function_call= False):

        if is_function_call:

            Se code.startswith("Extruder("):

                # Interceptar o comando da extrusora.

                # se a chamada do programa for Extruder(123.56)

                # extraímos o número como uma string

                # e convertê-lo em um número

                self.PRINT_E_NEW= float(code[9:-1])

                # Pular a geração da chamada do programa

                retorno

            E mais:

                self.addline(code + "()")

        E mais:

            # Código do programa de saída

            self.addline(code)

O valor da extrusora (length/E) é salvo como a variável PRINT_E_NEW no pós-processador do robô.

Precisamos acionar uma chamada de função chamada new_move a cada nova instrução de movimento linear. Podemos adicionar essa chamada no início do comando MoveL:

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

        """Add-in a linear movement"""

        # Manuseio da impressão 3D Integração da extrusora

        self.new_move(pose)    

       ...

Também devemos adicionar as seguintes variáveis no cabeçalho do pós-processador para calcular os incrementos da extrusora:

    # Parâmetros de configuração da extrusora de impressão 3D:

    PRINT_E_AO= 5 # ID da saída analógica para comandar o fluxo da extrusora

    PRINT_SPEED_2_SIGNAL= 0.10 # Proporção para converter velocidade/fluxo em um sinal de saída analógico

    PRINT_FLOW_MAX_SIGNAL= 24 # Sinal máximo a ser fornecido à extrusora

    PRINT_ACCEL_MMSS= -1 # Aceleração, -1 pressupõe velocidade constante se usarmos arredondamento/mistura

    # Parâmetros internos de impressão 3D

    PRINT_POSE_LAST= None # Última pose impressa

    PRINT_E_LAST= 0 # Comprimento da última extrusora

    PRINT_E_NEW= None # Novo comprimento da extrusora

    PRINT_LAST_SIGNAL= None # Último sinal da extrusora

Por fim, precisamos definir um novo procedimento que gerará comandos apropriados de alimentação da extrusora de acordo com a distância entre os movimentos, a velocidade e a aceleração do robô. Isso pressupõe que o avanço da extrusora seja acionado por uma saída analógica específica ou por uma chamada de programa personalizada.

Precisamos adicionar o seguinte código antes da definição do programa def MoveL.

    def calculate_time(self, distance, Vmax, Amax=-1):

        """Calcule o tempo para percorrer uma distância com a aceleração máxima e a velocidade máxima V"""

        se Amax< 0:

            # Assumir velocidade constante (o parâmetro de suavização/arredondamento apropriado deve ser definido)

            Ttot= distância/Vmax

        E mais:

            # Suponha que aceleramos e desaceleramos

            tacc= Vmax/Amax;

            Xacc= 0,5*Amax*tacc*tacc;

            Se a distância<= 2*Xacc:

                # Vmax não é atingido

                tacc= sqrt(distance/Amax)

                Ttot= tacc*2

            E mais:

                # Vmax é atingido

                Xvmax= distância - 2*Xacc

                Tvmax= Xvmax/Vmax

                Ttot= 2*tacc+ Tvmax

        retornar Ttot

    def new_move(self, new_pose):                       

        """Implementar a ação na extrusora para impressão 3D, se aplicável"""

        se self.PRINT_E_NEW for None ou new_pose for None:

            retorno

        # Pule o primeiro movimento e lembre-se da pose

        se self.PRINT_POSE_LAST for None:

            self.PRINT_POSE_LAST= new_pose

            retorno         

        # Calcular o aumento de material para o próximo movimento

        add_material= self.PRINT_E_NEW - self.PRINT_E_LAST

        self.PRINT_E_LAST= self.PRINT_E_NEW

        # Calcular a velocidade do robô e o sinal da extrusora

        extruder_signal= 0

        se add_material> 0:

            distance_mm= norm(subs3(self.PRINT_POSE_LAST.Pos(), new_pose.Pos()))

            # Calcular o tempo de movimento em segundos

            time_s= self.calculate_time(distance_mm, self.SPEED_MMS, self.PRINT_ACCEL_MMSS)

            # Evite a divisão por 0

            se time_s> 0:

                # Isso pode parecer redundante, mas permite que Vocêleve em conta as acelerações e podemos aplicar pequenos ajustes de velocidade

                speed_mms= distance_mm / time_s

                # Calcular a velocidade da extrusora em RPM*Ratio (PRINT_SPEED_2_SIGNAL)

                extruder_signal= speed_mms * self.PRINT_SPEED_2_SIGNAL

        # Verifique se o sinal está dentro dos valores aceitos

        extruder_signal= max(0,min(self.PRINT_FLOW_MAX_SIGNAL, extruder_signal))

        # Atualizar a velocidade da extrusora quando necessário

        se self.PRINT_LAST_SIGNAL for None ou abs(extruder_signal - self.PRINT_LAST_SIGNAL)> 1e-6:

            self.PRINT_LAST_SIGNAL= extruder_signal

            # Use a função setDO integrada para definir uma saída analógica

            self.setDO(self.PRINT_E_AO, "%.3f" % extruder_signal)

            # Como alternativa, provoque uma chamada de programa e cuide da integração com o controlador do robô

            #self.addline('ExtruderSpeed(%.3f)' % extruder_signal)

        # Lembre-se da última pose

        self.PRINT_POSE_LAST= new_pose