Como os movimentos delta são calculados?

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

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

Nos deltas, mesmo para movimentos simples, é necessário mover mais de um motor. E apenas calcular a quantidade de etapas em cada eixo necessário para alcançar o destino provavelmente dá um movimento curvo.

Então, qual é o algoritmo para calcular as etapas de uma determinada movimentação para uma impressora delta?

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 vários subsegmentos muito pequenos ("Segmentação")
2. Use alguma trigonometria básica ou o teorema de Pitágoras para vincular a posição da extrusora à altura do carro de cada uma das três torres ("cinemática inversa") para encontrar a posição de destino 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 efetoras é calculada a partir das coordenadas XY do bico 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 através do teorema de Pitágoras
• O comprimento do lado superior é adicionado à altura do bico Z 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 Algumas fotos relevantes:

Esses cálculos cinemáticos inversos são realizados para cada carro para obter uma posição de destino "espaço do carro", e isso é realizado para cada sub-segmento de caminho.

Os resultados dessas etapas podem ser reinseridos novamente nas técnicas de interpolação de caminho linear padrão para a impressora, nas quais são executadas etapas nas proporções necessárias e nas taxas necessárias para produzir o movimento linear desejado e o perfil de aceleração / velocidade desejado. (Como isso é feito é uma pergunta diferente.)

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

* ( A velocidade constante antes da desaceleração da aceleração é aplicada a fim de obedecer às restrições da dinâmica. De novo, esse é o assunto de uma pergunta 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 acompanhamento de caminho. A principal diferença conceitual entre desenhar arcos circulares e caminhos de movimento Delta é que o chamado "arco facetado" com Segmentação Delta é construído em coordenadas altura-tempo em vez das coordenadas X-Y-Y que você usaria para desenhar um círculo na tela do computador.

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

Técnicas evoluíram ao longo dos anos. E abordagens alternativas são frequentemente usadas: por exemplo, o fork do dc42 do RepRapFirmware executa o caminho exato 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 de polígono tão alta que cada pixel na tela obtém sua própria faceta . Portanto, é exatamente tão preciso quanto a resolução de posicionamento dos motores permite. A desvantagem é que essa técnica sem segmentação é bastante intensiva em processador, portanto, funciona apenas em controladores relativamente rápidos, e não no AVR Atmega de 8 bits mais antigo, que hoje alimenta a maioria das impressoras amadores / amadores existentes.

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

Estou descrevendo como isso é feito no firmware do Marlin.

O primeiro passo é dividir um movimento linear de (x, y, z) para (x ', y', z ') em muitos segmentos discretos. Para esse fim, é calculada a quantidade de tempo que a movimentação levaria em uma determinada velocidade 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 calcular_delta :

void calculate_delta(float cartesian[3]) {
    //reverse kinematics.
    // Perform reversed kinematics, and place results in delta[3]
    // The maths and first version has been done by QHARLEY . Integrated into masterbranch 06/2014 and slightly restructured by Joachim Cerny in June 2014

    float SCARA_pos[2];
    static float SCARA_C2, SCARA_S2, SCARA_K1, SCARA_K2, SCARA_theta, SCARA_psi;

    SCARA_pos[X_AXIS] = cartesian[X_AXIS] * axis_scaling[X_AXIS] - SCARA_offset_x;  //Translate SCARA to standard X Y
    SCARA_pos[Y_AXIS] = cartesian[Y_AXIS] * axis_scaling[Y_AXIS] - SCARA_offset_y;  // With scaling factor.

    #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;  // Multiply by 180/Pi  -  theta is support arm angle
    delta[Y_AXIS] = (SCARA_theta + SCARA_psi) * SCARA_RAD2DEG;  //       -  equal to sub arm angle (inverted motor)
    delta[Z_AXIS] = cartesian[Z_AXIS];
}

Essa função cuida da geometria delta e dos cálculos necessários para converter as coordenadas (x, y, z) dos pontos de extremidade 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, na verdade, faz com que essas etapas aconteçam.

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

O que é importante observar é que plan_buffer_line move os carros linearmente, e o cabeçote de impressão descreve um arco e não uma linha reta. Um movimento de linha reta é assim aproximado por muitos pequenos arcos.