Desenvolvendo um hexapod a partir do zero (parte 4) - trajetórias e sequências matemáticas

Olá pessoal! O desenvolvimento do hexapod foi um passo além. Desta vez, as trajetórias do movimento dos membros são implementadas e testadas - a próxima parte da matemática do movimento. Neste artigo, falarei sobre essas trajetórias e seqüências básicas de movimento. Espero que seja interessante.

Etapas do desenvolvimento:
Parte 1 - Design
Parte 2 - montagem
Parte 3 - Cinemática
Parte 4 - trajetórias e sequências matemáticas
Parte 5 - Eletrônica
Parte 6 - transição para impressão 3D
Parte 7 - nova caixa, software aplicativo e protocolos de comunicação

Trajetórias

A essência desse mecanismo é que, quando você define dois pontos, pode escolher a trajetória do membro. Ao passar de um ponto para outro, as coordenadas mudam de acordo com certas equações paramétricas. O mecanismo acabou por ser bastante poderoso e permite obter curvas interessantes para o movimento. Ele também implementa a suavização dos movimentos, alterando a etapa do parâmetro t - quanto menor a etapa, mais pontos intermediários haverá, menor a velocidade e maior a suavidade do movimento.

O procedimento para definir parâmetros de trajetória em alguns lugares é um pouco incompreensível e você pode ficar confuso. A dificuldade reside no fato de que, ao definir as coordenadas dos pontos inicial e final, as coordenadas dos pontos reais no espaço nem sempre são definidas, ou seja, algumas coordenadas definem os parâmetros de trajetória. Eu tive que escrever um programa que exibisse um determinado caminho e, ao mesmo tempo, verifique a acessibilidade de cada ponto do caminho.

O driver suporta os seguintes caminhos de movimento:

1. XYZ_LINAR é a mais simples de todas as trajetórias. A trajetória é usada quando se move para frente, para trás, para cima e para baixo. Todas as coordenadas mudam linearmente e são calculadas da seguinte maneira:
   
   

   x = t * (x1 - x0) / 180.0f + x0; y = t * (y1 - y0) / 180.0f + y0; z = t * (z1 - z0) / 180.0f + z0; 

   
   Aqui entendemos que não há problemas. As coordenadas especificam os ângulos paralelepípedos e coincidem com as coordenadas reais. O movimento ocorre ao longo da diagonal da caixa.
   
   
   Visualização de trajetória

   
   
   
   
   
   
2. YZ_ARC_Y_LINEAR - essa trajetória permite implementar o movimento ao longo de um arco. A trajetória é usada ao girar, quando você precisa mover um membro no chão. As coordenadas são calculadas da seguinte maneira:
   
   

    float R = sqrt(x0 * x0 + z0 * z0); float atan0 = RAD_TO_DEG(atan2(x0, z0)); float atan1 = RAD_TO_DEG(atan2(x1, z1)); float t_mapped_rad = DEG_TO_RAD(t * (atan1 - atan0) / 180.0f + atan0); x = R * sin(t_mapped_rad); // Circle Y y = t * (y1 - y0) / 180.0f + y0; z = R * cos(t_mapped_rad); // Circle X 

   
   É aqui que a diversão começa. As coordenadas especificam a direção dos raios para limitar o arco e podem não coincidir com as coordenadas reais. Os raios estão no mesmo plano, enquanto o raio do círculo é igual ao comprimento do vetor até o ponto inicial.
   
   
   Visualização de trajetória

   
   
   
   
   
   
3. XZ_ARC_Y_SINUS - essa trajetória também permite implementar o movimento ao longo de um arco, mas mais complexo que YZ_ARC_Y_LINEAR. A trajetória é usada ao girar, quando você precisa mover um membro pelo ar. As coordenadas são calculadas da seguinte maneira:
   
   

    float R = sqrt(x0 * x0 + z0 * z0); float atan0 = RAD_TO_DEG(atan2(x0, z0)); float atan1 = RAD_TO_DEG(atan2(x1, z1)); float t_mapped_rad = DEG_TO_RAD(t * (atan1 - atan0) / 180.0f + atan0); x = R * sin(t_mapped_rad); // circle Y y = (y1 - y0) * sin(DEG_TO_RAD(t)) + y0; z = R * cos(t_mapped_rad); // circle X 

   
   A diversão continua. As coordenadas também especificam a direção dos raios para limitar o arco, mas NÃO coincidem com as coordenadas reais. A coordenada Y do ponto de destino define a altura do seno.
   
   
   Visualização de trajetória

   
   
   
   
4. XZ_ELLIPTICAL_Y_SINUS - essa trajetória permite implementar o movimento ao longo de uma elipse. A trajetória é usada quando se move para frente e para trás, quando você precisa mover um membro pelo ar. Essa trajetória é uma complicação do XZ_ARC_Y_SINUS e foi necessária apenas devido à marcha visualmente feia ao usar o XZ_ARC_Y_SINUS (pernas estendidas demais). As coordenadas são calculadas da seguinte maneira:
   
   

    float a = (z1 - z0) / 2.0f; float b = (x1 - x0); float c = (y1 - y0); x = b * sin(DEG_TO_RAD(180.0f - t)) + x0; // circle Y y = c * sin(DEG_TO_RAD(t)) + y0; z = a * cos(DEG_TO_RAD(180.0f - t)) + z0 + a; 

   
   As coordenadas especificam os ângulos paralelepípedos e NÃO coincidem com as coordenadas reais. O movimento ocorre nos cantos inferiores da caixa, localizados no mesmo plano em que tocam a parte superior da peça. É melhor olhar para a foto no spoiler, não sei como descrevê-la brevemente em palavras.
   
   
   Visualização de trajetória

   
   

Isso completa a matemática básica do movimento do hexápode. No meu projeto, este é um mínimo necessário para a implementação de quase qualquer movimento.

Sequências

Pouco de teoria

Sequências são as ações elementares que compõem a marcha. Eles são divididos em cíclicos e não cíclicos.

• Sequências cíclicas podem ser realizadas várias vezes e, ao final de cada ciclo, os membros devem retornar à sua posição original (movimento e rotação);
• Sequências não cíclicas são realizadas apenas uma vez (subida e descida);

Cada sequência possui três blocos de iteração: bloco de preparação, bloco principal, bloco de conclusão.

• Bloco de treinamento - contém iterações para mover os membros para a posição inicial da sequência. No meu caso, avançar exige colocar as pernas em uma certa posição antes de começar a se mover. É executado uma vez após a transição para a sequência;
• Bloco principal - contém a iteração principal da sequência. Pode ser realizado ciclicamente;
• Conclusão do bloco - contém iterações para mover os membros para a posição base (a posição na qual os membros são definidos após o levantamento);

A figura abaixo mostra a sequência para avançar.

• Pontos vermelhos indicam a posição inicial dos membros antes de começar a se mover
• Linhas azuis indicam as trajetórias do membro no chão
• As linhas pretas indicam as trajetórias do membro no ar
• As setas indicam a sequência

As coordenadas dos pontos são selecionadas com base na configuração da caixa. Escolhi os pontos o mais próximo possível do corpo para reduzir o comprimento da alavanca. Em um ciclo da sequência, o hexápode se move 18 cm (em 1 ciclo, são executados 2 passos - 1 passo em 3 membros). Se você aumentar a distância, os membros começarão a se agarrar. Este parâmetro é limitado apenas pela configuração do caso.


A sequência é definida por dois pontos (1, 2) para cada membro e são utilizados dois caminhos: XYZ_LINEAR (linhas azuis) e XZ_ELLIPTICAL_Y_SINUS (linhas pretas). O ponto 1 é usado pelo caminho XZ_ELLIPTICAL_Y_SINUS para definir a altura do seno e, consequentemente, a altura em que a perna subirá. Os pontos 2 e 3 são pontos reais que um membro atinge ao se mover.

A localização dos pontos depende apenas da sua imaginação e das capacidades do hexapod. Talvez tudo tenha sido um pouco complicado e exista uma opção mais simples, mas, aparentemente, ainda não o alcancei.

Implementação

Agora vamos dar uma olhada na implementação de toda essa felicidade. Estruturas com parâmetros de sequência são as seguintes:

 typedef struct { point_3d_t point_list[SUPPORT_LIMB_COUNT]; path_type_t path_list[SUPPORT_LIMB_COUNT]; uint32_t smooth_point_count; } sequence_iteration_t; typedef struct { bool is_sequence_looped; uint32_t main_sequence_begin; uint32_t finalize_sequence_begin; uint32_t total_iteration_count; sequence_iteration_t iteration_list[15]; sequence_id_t available_sequences[SUPPORT_SEQUENCE_COUNT]; } sequence_info_t; 

sequence_iteration_t - contém informações sobre a iteração da sequência:

• point_list - uma matriz de pontos para cada membro no formato XYZ;
• path_list - uma matriz de trajetórias para cada membro;
• smooth_point_count - define o número de pontos do caminho (etapa do parâmetro t);

sequence_info_t - contém informações sobre toda a sequência:

• is_sequence_looped - define o tipo de sequência: cíclica ou não;
• main_sequence_begin - define o índice inicial do bloco principal na matriz iteration_list;
• finalize_sequence_begin - define o índice inicial do bloco de conclusão na matriz iteration_list;
• total_iteration_count - define o número de iterações na sequência;
• iteration_list - uma matriz de iterações;
• available_sequences - define a lista de seqüências disponíveis para a transição da atual (por exemplo, não podemos começar a andar sem nos levantar do chão);

NOTA: O índice do bloco de preparação não é intencionalmente indicado; ele está sempre localizado no início da matriz de iteração.

Infelizmente, não consigo imaginar o código de definição de sequência aqui, porque é bastante largo e parece terrível após as transferências. Acabei de deixar um link para o arquivo de definição aqui.

Esquema de processamento de movimento

Vale a pena distinguir todos os círculos do inferno pelos quais a sequência passa em tempo de execução. O esquema de processamento é o seguinte:

1. MOTOR DE MOVIMENTO - organiza o processamento e a alternância entre seqüências. Nenhum cálculo é realizado lá. Se simplificado, este módulo desliza o próximo ponto para o módulo LIBMS DRIVER após a conclusão do processamento atual.
   Entrada do módulo: matriz de coordenadas dos pontos de destino.
   Saída do módulo: ponto de destino para a iteração atual da sequência.
2. O LIBMS DRIVER é o mais complexo de todos os módulos. Toda a matemática do movimento reina aqui: cinemática inversa, cálculos de trajetória e suavização de movimentos. Este módulo possui uma sincronização estrita com o módulo PWM. Os cálculos são realizados com uma frequência de 150Hz, respectivamente, o pulso de controle para os inversores também é fornecido com uma frequência de 150Hz.
   Entrada do módulo: coordenadas do ponto de destino.
   Saída do módulo: ângulos de rotação do servo.
3. MOTORISTA DO SERVO . Não há nada de especial nele, exceto vários parâmetros para instalar e ajustar os inversores.
   Entrada do módulo: ângulos de rotação do servo.
   Saída do módulo: controle a largura do pulso.
4. EXCITADOR DE PWM . Software de driver PWM para controle de unidade. Aqui os pinos apenas se contraem no momento certo. A variável de sincronização sincronizada do PWM é incrementada a cada período do PWM.
   Entrada do módulo: controle a largura do pulso.
   Saída do módulo: pulsos nos pinos de controle.

Tentei tornar os módulos independentes um do outro e consegui. Isso permite inserir neste circuito qualquer módulo intermediário (por exemplo, o módulo de adaptação à paisagem) e nada será interrompido ao mesmo tempo, enquanto a implementação ocorrerá com alterações mínimas no código.

Últimas notícias e lagostins do projeto encontrados