Questão:
Como os movimentos delta são calculados?
Lars Pötter
2016-02-24 00:14:24 UTC
view on stackexchange narkive permalink

Em uma impressora cartesiana, os movimentos são realmente simples. Se assumirmos que a impressora tem 100 passos / mm em cada eixo, então um movimento de 10 mm em um eixo é apenas 1000 passos naquele eixo.

Movimentos que não estão alinhados com um eixo também são simples. Mover de x, y = 0,0 para 10,10 seria 1000 passos em xey.

Em deltas, mesmo para movimentos simples, mais do que um motor precisa se mover. E apenas calcular a quantidade de etapas em cada eixo necessárias para chegar ao destino provavelmente resulta em um movimento curvo.

Então, qual é o algoritmo para calcular as etapas de um determinado movimento para uma impressora delta?

Esta parece ser apenas uma questão teórica que pode ser mais apropriada para um site que lida com programação e / ou matemática, visto que a forma como o firmware funciona internamente é irrelevante para o uso de uma impressora 3D. Por outro lado, a questão é específica da impressão 3D e pode ser relevante para alguém que está tentando modificar ou ajustar o firmware da impressora.
Dois respostas:
Ryan Carlyle
2016-02-24 02:40:25 UTC
view on stackexchange narkive permalink

Existem duas etapas especiais principais para a técnica usada pela maioria dos controladores de impressora 3D de código aberto:

  1. Divida cada segmento gcode linear em muitos subsegmentos muito pequenos ("Segmentação")
  2. Use alguma trigonometria básica ou o teorema de Pitágoras para amarrar a posição da extrusora à altura do carro para cada uma das três torres ("Cinemática Inversa") para encontrar a posição alvo para cada pequeno segmento

A cinemática inversa é surpreendentemente simples. Um triângulo virtual de 90 graus é construído a partir de dois comprimentos conhecidos para resolver o terceiro comprimento desconhecido:

  • O comprimento fixo do braço delta é a hipotenusa do triângulo
  • A distância horizontal entre as juntas da coluna e as juntas do efetor final é calculado a partir das coordenadas XY do bocal e da posição fixa da coluna, para determinar o comprimento do lado inferior do triângulo
  • O comprimento do lado superior do triângulo é calculado a partir dos dois anteriores por meio do teorema de Pitágoras
  • O comprimento do lado superior é adicionado à altura Z do bocal para obter a altura necessária do carro

Acho que a melhor referência de código aberto aqui é o documento Rostock Kinematics de Steve Grave, rev3 disponível para download aqui: https://groups.google.com/d/msg/deltabot/V6ATBdT43eU/jEORG_l3dTEJ Alguns relevantes imagens: enter image description here enter image description here

Esses cálculos de cinemática inversa são realizados para cada carro para obter uma posição alvo de "espaço do carro" , e isso é realizado para cada subsegmento de caminho.

Os resultados dessas etapas podem ser reinseridos nas técnicas de interpolação de caminho linear padrão para a impressora, em que ela dispara etapas nas proporções necessárias e nas taxas necessárias para produzir o movimento em linha reta desejado e o perfil de aceleração / velocidade. (Como ISSO é feito é uma questão diferente.)

O efeito líquido é que a impressora se moverá por uma série de pequenos movimentos "lineares" do carro (linear significa velocidade constante * em relação ao tempo) que coletivamente aproximam os movimentos curvos (posição quadrática em relação ao tempo) necessários do carro para produzir um movimento de efetor final em linha reta.

* ( Velocidade constante antes que as desacelerações de aceleração sejam aplicadas para obedecer às restrições de dinâmica, de qualquer maneira. Novamente, esse é o assunto de uma questão diferente.)

A segmentação é muito semelhante ao processo de usar um polígono para aproximar um círculo. Se as facetas forem pequenas o suficiente, o polígono é uma boa aproximação. Taxas de segmentação mais altas produzem menos erros de seguimento de caminho. A principal diferença conceitual entre desenhar arcos de círculo e caminhos de movimento Delta é que o chamado "arco facetado" com Segmentação Delta é construído em coordenadas de altura vs tempo em vez das coordenadas X-vs-Y que você usaria para desenhar um círculo em uma tela de computador.

Este sistema é usado em grande parte porque o suporte para impressoras estilo Delta foi originalmente aparafusado em planejadores de movimento baseados em GRBL, que foram escritos exclusivamente para caminhos de movimento em linha reta em impressoras cartesianas. Foi uma modificação relativamente mínima na base de código existente em comparação com a implementação da interpolação de caminho quadrático completo.

As técnicas evoluíram ao longo dos anos. E abordagens alternativas são freqüentemente usadas: por exemplo, o fork dc42 de RepRapFirmware executa o caminho exato seguindo sem segmentação, recalculando o tempo adequado para a próxima etapa após cada etapa . Isso é funcionalmente equivalente a aproximar um círculo com uma contagem de facetas do polígono tão alta que cada pixel na tela tem sua própria faceta . Portanto, é exatamente tão preciso quanto permite a resolução de posicionamento dos motores. A desvantagem é que essa técnica livre de segmentação exige bastante do processador, portanto, ela só funciona em controladores relativamente rápidos, não no antigo Atmega AVR de 8 bits que alimenta a maioria das impressoras atuais para consumidores / amadores.

Outras técnicas são possíveis. A literatura acadêmica de controle de robótica paralela é um outro mundo de técnicas matemáticas e complexidade para produzir algoritmos de controle generalizados que funcionam para uma ampla gama de mecanismos de robôs. A versão que usamos nas impressoras 3D de código aberto é bastante simples e, em comparação, específica do aplicativo.

Tom van der Zanden
2016-02-24 02:22:49 UTC
view on stackexchange narkive permalink

Estou descrevendo como isso é feito no firmware Marlin.

A primeira etapa é dividir um movimento linear de (x, y, z) para (x ', y', z ') em muitos segmentos discretos. Para este fim, a quantidade de tempo que o movimento levaria em uma determinada velocidade é calculada, e o valor delta_segments_per_second é usado para calcular o número de segmentos usados.

Isso é feito na função prepare_move_delta no arquivo Marlin_main.cpp. Os pontos finais de cada um desses segmentos são então passados ​​para a função calculate_delta:

  void Calculate_delta (float cartesian [3]) {// cinemática reversa. // Execute a cinemática reversa e coloque os resultados no delta [3] // A matemática e a primeira versão foram feitas por QHARLEY. Integrado na masterbranch 06/2014 e ligeiramente reestruturado por Joachim Cerny em junho de 2014 float SCARA_pos [2]; flutuação estática SCARA_C2, SCARA_S2, SCARA_K1, SCARA_K2, SCARA_theta, SCARA_psi; SCARA_pos [X_AXIS] = cartesiano [X_AXIS] * axis_scaling [X_AXIS] - SCARA_offset_x; // Traduzir SCARA para o padrão X Y SCARA_pos [Y_AXIS] = cartesiano [Y_AXIS] * axis_scaling [Y_AXIS] - SCARA_offset_y; // Com fator de escala. #if (Linkage_1 == Linkage_2) SCARA_C2 = ((sq (SCARA_pos [X_AXIS]) + sq (SCARA_pos [Y_AXIS])) / (2 * (float) L1_2)) - 1; #else SCARA_C2 = (sq (SCARA_pos [X_AXIS]) + sq (SCARA_pos [Y_AXIS]) - (float) L1_2 - (float) L2_2) / 45000; #endif SCARA_S2 = sqrt (1 - sq (SCARA_C2)); SCARA_K1 = Linkage_1 + Linkage_2 * SCARA_C2; SCARA_K2 = Linkage_2 * SCARA_S2; SCARA_theta = (atan2 (SCARA_pos [X_AXIS], SCARA_pos [Y_AXIS]) - atan2 (SCARA_K1, SCARA_K2)) * -1; SCARA_psi = atan2 (SCARA_S2, SCARA_C2); delta [X_AXIS] = SCARA_theta * SCARA_RAD2DEG; // Multiplique por 180 / Pi - theta é o ângulo do braço de suporte delta [Y_AXIS] = (SCARA_theta + SCARA_psi) * SCARA_RAD2DEG; // - igual ao ângulo do braço auxiliar (motor invertido) delta [Z_AXIS] = cartesiano [Z_AXIS];}  

Esta função cuida da geometria delta e dos cálculos necessários para converter as coordenadas (x, y, z) das extremidades do segmento em posições correspondentes para os carros. As coordenadas traduzidas são então passadas para plan_buffer_line , que calcula as etapas necessárias para cada motor de passo e realmente faz essas etapas acontecerem.

A cinemática exata usada nesta função é explicada em muitos mais detalhes no github Marlin.

O que é importante notar é que plan_buffer_line move os carrinhos linearmente, e a cabeça de impressão descreve um arco e não uma linha reta. Um movimento em linha reta é, portanto, aproximado por muitos pequenos arcos.

O código é difícil de ler. O que é SCARA? Você poderia descrever as etapas que o código implementa?


Estas perguntas e respostas foram traduzidas automaticamente do idioma inglês.O conteúdo original está disponível em stackexchange, que agradecemos pela licença cc by-sa 3.0 sob a qual é distribuído.
Loading...