Comment mettre à jour le quaternion basé sur 3d gyro données?

J'ai eu un premier quaternion , q0. Et je reçois vitesse angulaire arpentage, je peux intégrer les vitesses j'ai donc eu 3 angles à 50Hz. Comment faire un quaternion est basé sur les 3 angles? Je ne peux pas juste faire 3 quaternions, puis-je?

Afin de le rendre clair.

Q. nouveaux=Q. nouveau*Q. mise à jour(alpha,bêta,gamma)

Q. nouvelles représente mon orientation actuelle dans un quaternion, je veux le mettre à jour en multipliant avec un Q. mise à jour de quaternion. Comment puis-je faire le Q. mise à jour avec les angles?

Merci!

La triste nouvelle est: C'est beaucoup plus compliqué que ça. Voir par exemple Orientation de l'estimation à l'aide d'un quaternion indirecte fondée filtre de Kalman adaptatif estimation de l'externe accélération. Au fait, comment allez-vous traiter avec le gyroscope de la dérive?
Cette question ne semble pas être sur la programmation dans le champ d'application défini dans le centre d'aide.
Désolé les gars. J'ai juste commencé à travailler en tant que développeur de logiciels il y a 2 semaines et c'est ma première question ici(le plus drôle, c'est que je suis un ingénieur en mécanique :D). Vous êtes les meilleurs!!! À propos de la dérive? Je Ne sais pas encore.

OriginalL'auteur user3598726 | 2014-05-06

  1. 6

    Vous pouvez simplement intégrer votre vitesse angulaire pour obtenir la position angulaire (angles d'Euler), de convertir les angles d'Euler pour les Quaternions, puis multiplier le Quaternion d'accumuler de l'orientation.

    Supposons que votre entrée est donnée par un vecteur 3D de la vitesse angulaire: omega = (alpha, bêta, gamma), donnée par degrés par seconde. Pour obtenir les angles d'Euler, E, en degrés, multipliez omega par le changement dans le temps, que nous pouvons appeler dt. Il en résulte:

    Vector3D omega = new Vector3D(alpha, beta, gamma);
Vector3D E = omega * dt;

    Vous pouvez obtenir dt en soustrayant l'heure actuelle au moment de votre mise à jour précédente. Après l'obtention de la 3D angles d'Euler de gyroscope de données, de le convertir en un Quaternion (w,x,y,z) par le biais de cette équation (à partir de Wikipedia):

    float w = cos(E.x/2) * cos(E.y/2) * cos(E.z/2) + sin(E.x/2) * sin(E.y/2) * sin(E.z/2);
float x = sin(E.x/2) * cos(E.y/2) * cos(E.z/2) - cos(E.x/2) * sin(E.y/2) * sin(E.z/2);
float y = cos(E.x/2) * sin(E.y/2) * cos(E.z/2) + sin(E.x/2) * cos(E.y/2) * sin(E.z/2);
float z = cos(E.x/2) * cos(E.y/2) * sin(E.z/2) - sin(E.x/2) * sin(E.y/2) * cos(E.z/2);

Quaternion q = new Quaternion(w, x, y, z);

    Il suffit de copier-coller les deux extraits de code ci-dessus dans votre Q. méthode update (), puis retourner le Quaternion. Si vous voulez savoir comment l'équation fonctionne, il suffit de consulter le lien Wiki et de lire à travers elle.

    Je suis sûr que c'est faux. La première partie est à proximité. L'intégration de la vitesse angulaire vous donne la variation de la position angulaire qui est une rotation de l'orientation de départ. Le vecteur de rotation a des composantes x,y et z, mais, de manière significative, ce ne sont pas des angles d'Euler. La rotation se produit autour de l'axe de rotation et simultanément sur les trois axes. Une autre réponse donne une assez étroite relation de x,y,z pour le quaternion. Angles d'Euler décrire rotation séquentielle un ensemble de trois rotations et il y a plusieurs conventions pour l'ordre séquentiel.

    OriginalL'auteur Enrico Tiongson

  2. 5

    Je présume que vous êtes intégration des angles d'euler parce que vous aimez vous compliquer la vie. D'abord et avant tout le gyro ne pas intégrer directement dans votre angles d'euler. Si vous demandez à cette question, je vais supposer que vous ne savez pas comment trouver le taux de variation angles d'euler de votre gyro mesures. Vous avez besoin d'une matrice de transformation pour que cela fonctionne. Je recommande fortement de prendre un exemplaire de Farrell "Aidé navagition" À la page 57, il explique comment calculer la matrice de transformation pour modifier votre gyro dans les taux d'Euler taux. Mais pourquoi s'embêter quand vous pouvez obtenir votre taux de changement de quaternions directement à partir du quaternion et de votre gyro données:

    rate of change quaternion  = qdot
quaternion = q
gyro quaternion = w = [0,gyrox,gyroy,gyroz]

    donc

    qdot = 0.5 *  q Ⓧ w

    où Ⓧ représente le produit de quaternions. Soyez prudent avec vos images ici. Le gyro représente l'angle de taux du capteur d'image à l'égard de l'inertie image représentée dans le capteur d'image. Cela signifie que votre quaternion doit représenter un semblable rotation du capteur à l'inertie cadre. Dans ce cas, il doit représenter une rotation de l'inertie cadre pour le gyro cadre. Si l'on fait abstraction des choses comme la rotation de la terre, l'équation précédente est valide.

    Être au courant au sujet de "Aidé de Navigation." À mon avis, son traitement de quaternions est très déroutant.

    Ce sujet de la commande de roulis,tangage,lacet de la multiplication des quaternions parce que rouleau x hauteur n'est pas égale à la hauteur x de les rouler dans la multiplication des quaternions
    Pouvez-vous veuillez donner des précisions? Pourquoi gyro de données peut être utilisée avec 0 de la rotation de quaternions et qu'est-ce que l'0,5 dans votre qdot = 0.5 * q Ⓧ w signifie? devrions-nous scalaire multiplier le quaternion q? Où est l'échelle de temps passé?
    Concernant l'utilisation de 0...Le soi-disant gyro quaternion définis dans cette réponse représente un vecteur dans l'espace 3d et en tant que telle, elle a un "scalaire" égal à zéro. Ce qui est nécessaire pour permettre une rotation-quaternion (non nul partie scalaire) pour effectuer une rotation sur le vecteur lors de l'utilisation de la multiplication des quaternions. Info clé ici est que les quaternions peut représenter à la fois les vecteurs(avec trois composants de base) et des rotations (qui est un angle de tourner autour d'une direction). Ce sont deux choses totalement différentes. Certes, c'est la confusion.
    Concernant le rouleau x hauteur n'est pas la même hauteur x rouleau. Ce problème est résolu par la compréhension que les trois angles (gyroX * dt, gyroY *dt, et gyroZ * dt) ne sont pas des angles d'Euler. Ce sont les composantes du vecteur de rotation. C'est qu'ils sont des rotations qui se produisent sur le x, y et z axes simultanément avec l'tourner sur l'axe de rotation. Il y a plusieurs Euler angle des représentations de cette même rotation en fonction de ce que la convention est utilisé. Mieux coller à l'axe et l'angle de la représentation, qui est étroitement liée à des quaternions
    Concernant le facteur de 0.5. Je crois que cela est lié au fait que l'angle de rotation g sur un axe avec les composantes (x,y,z) correspond à la quaternion: [cos g/2, sin g/2 x (x,y,z)]. Notez les demi-angles. Toutefois, cette réponse ne permet pas de créer les quaternions correctement. De mieux voir la réponse ci-dessous. Il est également décrite ici quaternion de rotation

    OriginalL'auteur Michael Baker

  3. 3

    Pardonnez-moi thread necromancing, mais toutes les réponses semblent compliquées et certains, comme moi, préfèrent cette plus "pratique":

    Dire omega=(alpha,bêta,gamma) est la valeur mesurée de la vitesse de vecteur des gyros. Puis nous nous déplaçons 

    theta = ||omega||*dt; //length of velocity vector

    nombre d'unités (deg ou rad dépend de gyro) autour de 

    v = omega /( ||omega|| ); //normalized orientation of velocity vector

    Ainsi, nous pouvons construire le quaternion de rotation:

    Q.update = (cos(theta/2),v_x * sin(theta/2), v_y * sin(theta/2), v_z * sin(theta/2));

    Tout ce qui reste maintenant est de faire tourner notre rotation actuelle par Q.update. C'est trivial:

    Q.new = multiply_quaternions(Q.update,Q.new); 
//note that Q.update * Q.new != Q.new * Q.update for quaternions

    Fait. Les Quaternions sont belles, n'est-ce pas?

    Quelques diapositives sur les gyroscopes et les quaternions qui peuvent être utiles:
    http://stanford.edu/class/ee267/lectures/lecture10.pdf

    Pourquoi êtes-vous à l'aide de Q. nouveaux = multiply_quaternions(Q. mise à jour,Q. nouveau) et non Q. nouveaux = multiply_quaternions(Q. nouvelles,Q. de mise à jour)? À la page 26 du script que vous avez lié, elles se multiplient par Q. mise à jour sur le côté droit.

    OriginalL'auteur FirefoxMetzger

  4. 0

    Vous pouvez convertir ces angles d'un seul quaternion, puis effectuer l'opération que vous avez décrit, ou vous pouvez convertir chacun d'eux à un axe de l'angle de la paire et puis à un quaternion, puis à multiplier les trois quaternions ensemble.
    Reportez-vous à http://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles et
    http://www.j3d.org/matrix_faq/matrfaq_latest.html#Q60 pour plus de détails.

    -1 Comme je l'ai dit ci-dessus dans le commentaire, c'est beaucoup plus compliqué que ça. S'il vous plaît supprimer cette réponse.
    J'ai supposé qu'il avait déjà de la rotation (alpha, bêta, et gamma) par rapport à la dernière orientation, et je voulais juste mettre à jour l'orientation actuelle en multipliant les deux quaternions. Il a d'abord demandé la suivante: "Comment faire un quaternion est basé sur les 3 angles? Je ne peux pas juste faire 3 quaternions, puis-je?". Pour cette question, je ne vois pas pourquoi ma réponse devrait recevoir un -1. Toutefois, si vous avez interprété sa question: "Comment puis-je obtenir de l'orientation à partir d'un gyro", alors bien sûr, il est beaucoup plus compliqué, et d'autres facteurs tels que le gyroscope de la dérive doit être considéré avant d'intégrer quoi que ce soit.
    Oui, il me semble que ce qu'il veut; on dirait qu'il est en train de suivre l'orientation. De son commentaire il est évident qu'il ne connaît pas le gyroscope de la dérive et de la façon de traiter avec elle. Lui dire comment faire la mise à jour n'est pas l'aide, mais dommage que vous aider à aller plus loin sur la mauvaise piste. Le plus tôt il se rend compte de la difficulté, la meilleure, et c'est ce que je considère comme aide à proprement parler.
    Agreee. Ce qui s'est passé j'ai répondu à sa question d'origine avant de le posté le commentaire. De toute façon, si il a de l'IMU (c'est à dire un gyroscope avec un accéléromètre), je suggère qu'il regarde dans Madgwick d'orientation du filtre. Il y a beaucoup de ressources en x-io.co.uk
    Je sais au sujet de la dérive, je la corriger à l'aide d'un accéléromètre à l'aide complémentaire de filtre 😀 j'ai pensé tout, ill après le code lors de son prêt

    OriginalL'auteur edu_

  5. 0

    1) La mise à jour elle-même est simple. Il suffit de créer quaternion de "angle de l'axe de la"représentation de la vitesse angulaire.

    BWT, commune de représenter la "vitesse angulaire" est un vecteur de 3 scalaires. Vecteur est parallèle à l'axe de momental rotation dans les LOCAUX cadre de l'objet. Si votre équation regardez: Q. nouveaux=Q. mise à jour(alpha,bêta,gamma)*Q. nouvelles.
    http://en.wikipedia.org/wiki/Axis%E2%80%93angle_representation#Unit_quaternions

    Et de prendre en compte le temps d'intégration (plus simple approximation, Euler intégration)
    Q. nouveaux = Q. fromVector(angularVelocity * deltaTime)*Q. nouvelles

    NOTER également, angularVelocity * deltaTime produire "exponentielle de la carte" la rotation, facile peut être converti en quaternion.

    Précis de l'intégration , de plus en plus compliqué approximation doit être utilisé. Mais vous devez connaître la signification exacte de vos mesures (temps de mesure, de bruit et plus).

    2) La fonction de mise à jour n'est pas clair à partir de votre question. Qu'est-ce que (alpha,bêta,gamma) paramètres? Si c'est un momental vitesse de rotation d'environ 3 un axe orthogonal , que vous pouvez construire la vitesse angulaire de ce tout simplement. Assurez-vous simplement en unités propres (en radians par seconde).

    3) La façon d'obtenir utile intégration des données des accéléromètres est trop compliqué pour la réponse courte. Chaque matériel doit être manipulé avec des propriétés personnalisées. Il doit être de fusible de données à partir d'accélération linéaire d'éviter toute dérive.

    Merci. Alors, Comment est-Q. de mise à jour(alpha,bêta,gamma) ressemble?
    Comme je l'ai dit , trop peu d'informations. Je peux deviner qu'il peut ressembler : mise à jour(alpha,bêta,gamma) { Vector3 r = Vector3(alpha,bêta,gamma) * deltaTimeSec; double l = r.longueur(); Quaternion rQ = (0.5*r.xsin(l)/l, 0.5*r.ysin(l)/l), 0.5*r.z*sin(l)/l, 0.5*cos(l) ); return rQ; }

    OriginalL'auteur minorlogic