Eu estou trabalhando em um quadrotor. Conheço sua posição - , para onde gostaria de ir - posição alvo b e, a partir disso, calculo um vetor c - um vetor unitário que me levará ao meu objetivo:$a$$b$$c$

c = b - a
c = normalize(c)

Como um quadrotor pode se mover em qualquer direção sem rotação, o que tentei fazer é

1. gire pelo ângulo de guinada dos robôs$c$
2. dividi-lo em seus componentes $x, y$
3. passe-os para o robô como ângulos de rotação e inclinação.

O problema é que, se a guinada for de 0 ° ± 5, isso funcionará, mas se a guinada estiver próxima de +90 ou -90, ela falhará e seguirá em direções erradas. Minha pergunta é: estou perdendo algo óbvio aqui?

Reimplementando sua solução, recebo o seguinte:

Ângulo entre vetores

Primeiro, você deseja o ângulo entre os pontos $A$ e $B$ - não especificamente o vetor unitário.

$\theta = math.atan2(B_{x}-A_{x}, B_{y}-A_{y})$

Ângulo de guinada do veículo

$\psi$$\theta$

Heading vs Yaw

$y$

$x$

A sobreposição de 90 graus entre essas medições, combinada com a adição (em vez de subtração) da guinada do veículo da guinada desejada, pode ser o motivo pelo qual as coisas funcionaram quando seu alvo estava dentro de ± 5 ° e se comportou mal em ± 90 °.

Conversão para o componente X e Y

$(\theta-\psi)$$x$$y$

Controle PID

Você pode ser melhor atendido usando loops de controle PID para a rotação e a inclinação do veículo. Ou seja, depois de corrigir seu código e conseguir atingir seu objetivo, meu palpite é que você começará a superá-lo - oscilando para frente e para trás. Um PID ajustado corretamente impedirá que isso aconteça enquanto ainda permite que você se aproxime do alvo rapidamente.

$x$$y$

Suponho que você esteja falando de um vetor 3D aqui. Você pode simplesmente generalizar normalize()assim? É tão comum (eu nunca vi isso, se for, então novidades para mim). Caso contrário, problemas óbvios de quebra da bússola se aplicam a cada um dos componentes X e Y. Por que não chamá-los de rolar e / ou lançar e / ou guinar? (misturar nomenclatura 3D e 2D confunde a pergunta).

Minha normalização 2D se parece com isso;

int Pilot_QuickestTurnTo(int hdgNow, int hdgNew)
{
    hdgNow = Pilot_Hdg360(hdgNow);
    hdgNew = Pilot_Hdg360(hdgNew);
    if (hdgNow < hdgNew)
        hdgNow += 360;
    int left = hdgNow - hdgNew;
        return (left < 181 ? -left : 360 - left);
}

Se é realmente um quad, presumo que seus componentes X e Y sejam realmente YAW, Altitude ((X, Y) e Z). Você precisará lidar com o YAW(X, Y)2D e simplesmente largar ou ganhar altitude para Z (e, novamente, é por isso que suspeito que normalizar é mais do que você tem).