Capteur d'orientation?

[dje8269]

Bonjour à tous,

Je cherche à me renseigner sur les différents capteur qui me permettrais de connaitre le sens d'orientation d'un objet.

Il est souvent expliqué plusieurs notions, et parfois même les deux à la fois, alors je me mélange un peu les pinceaux entre gyroscope, accéléromètre, magnétomètre etc...

Je souhaiterais un système qui n'as pas besoin de référencement, calibration.
Actuellement j'utilise 2 systèmes "mécaniques" qui sont pas trop mal mais parfois (quand je bouge la carte électronique doucement) il faut tapoter dessus pour que la position soit prise en compte. C'st pourquoi je cherche un sytéme à puce électronique. ( datasheet )
J'aimerais détecter l'orientation sur 3 axes comme sur le schéma suivant

Disons que la partie verte représente une table , et le CI l'objet et son orientation.

Voila si quelqu'un a une quelconque conaissance dans ce domaine je suis preneur de toute explication, conseils, suggestions.

Merci


-----

[Gwinver]

Bonjour.

Pour ce genre de problème, il faut s'orienter vers les exemples donnés à base Arduino ou autre processeur (ESP32, Raspberry etc. ...).
Cela permet d'identifier les composants et leur utilisation, voici un exemple:

https://www.raspberryme.com/guide-ar...cope-mpu-6050/

[antek]

Je souhaiterais un système qui n'as pas besoin de référencement, calibration.
J'aimerais détecter l'orientation sur 3 axes comme sur le schéma suivant

Dans quel contexte ? l'information doit être fournie en permanence, pendant une courte durée, avec quelle précision . . . ?

[dje8269]

Merci pour vos réponses.

Après quelques lectures, je vois mal comment un capteur pourrait m'aider.
En effet tous les capteurs utilise la force des mouvements , l'objet doit donc être en mouvement pour déterminer sa position dans l'espace par rapport à un point donné.

J'aimerais connaitre la position de mon objet posé sur une table. Non pas de données en permanence, seuelemt nquand la psotion a changée par exemple.
Pas de grande précision j'aimerais détecter seulement 4 positions? je prendrais comme analogie l'humain ( debout sur ses pieds, debout à l'envers( poirier) , allongé sur le cote gauche ou allongé sur le coté droit ).

[A voir en vidéo sur Futura]

[gts2]

Bonjour,

Dans ce cas un accéléromètre convient. Au repos, il va indiquer la direction du champ de pesanteur selon les trois axes de votre capteur, donc vous connaitrez la position de votre objet.

[Gwinver]

Les accéléromètres devraient pouvoir le faire, car ils sont sensibles à l'attraction terrestre.

Ayant les directions et les valeurs de trois accéléromètres, en l'absence de tout mouvement il n'y a que l'accélération verticale qui est proche de 9.81 m/s².
C'est d'ailleurs probablement de cette façon que fonctionnenet les applis de niveaux des smartphones.

Les smartphones sont équipés de capteurs, il est possible d'aller lire directement leurs valeurs, ou encore utiliser une appli comme phyphox (fonction : accélération avec g).

[dje8269]

Hummm... merci gts2 et Gwinver

Ok donc un accéléromètre peut me donner une orientation, même quand l'objet est fixe ? très intéressant.

Au repos dans n'importe quelle position, grâce à la l'attraction terrestre. Je crois que j'ai trouver ce qu'il me faut dans ce cas.

je viens de telecharger une application smartphone . C'est top ! exactement ce qu'il me faut.

J'ai repéré le MPU6050, qui me parait commun et documenté

[dje8269]

Une autre question me vient :

Est ce sensible aux metal ? puis le mettre dans une boite en métal ou avec du metal autour sans perturber les mesures ?

[Antoane]

Bonjour,

C'ets bien un accéléromètre qu'il semble te falloir.

Note que l'accéléromètre mesure l'accélération, donc si sa vitesse (vectorielle) varie, il sera trompé.
Il n'est pas sensible à l'environement.

Note queton capteur en #1 est aussi un accéléromètre - certe rudimentaire : il projette (avec un peu de frotement / d'hystérésis puisqu'il faut parfois le secouer un peu) et normalise (puisque le résultat est 0 ou 1) sur deux axes le vecteur accélération qu'il subit - ce vecteur étant (au repos dans le reférentiel terrestre) dirigé vers le bas.

[Gwinver]

Un accéléromètre n'est pas perturbé par un environnement métallique.

[dje8269]

Je sais pas si vous êtes chaud à ce point mais voila la situation.

Dans mes tiroirs j'ai dénicher un accéléromètre LIS2DW12

J'ai rapidement codé de quoi lire les valeurs.
Maintenant je me suis auto-chauffé pour obtenir un angle en degré avec les valeurs brute de l'accéléromètre.

J'ai configuré mon accéléro avec des valeurs sur 12bits et une échelle de +/-2g. d'aprés ma configuration le coefficient de sensibilité est de 0.976.

J'ai trouver une formule sur le net, mais cela dépasse très largement mes connaissances en mathématiques, pour pouvoir corriger.

Voici ma fonction en C qui lit les valeurs brut en mg ( milli G). Ces valeurs sont très précises et me semble correct.

Par exemple si je pose l'accelero a plat sur la table, j'ai Ax~=0 , Ay~=0, et Az~= 1050 .
1050 représente donc 1050 mg soit 1g l'attraction terrestre il me semble.

Par contre le calcul d'angle est foireux, ou je l'ai mal codé les valeurs sont pas ouf.


Il y a des problèmes pour afficher des float avec un printf , alors je fais tout les calculs en float, et à la fin je les met sur un entier pour pouvoir les afficher.

void LIS2DW12_Read_Accel()
{
uint64_t Total;
uint8_t Rec_Data[6];
uint8_t check;
float Angx, Angy, Angz;
float Ax, Ay, Az;

for (int var = 0; var < 6; ++var)
{
HAL_I2C_Mem_Read (&hi2c1, LIS2DW12_ADDR, 0x28+var, 1, &check, 1, 1000);
Rec_Data[var] = check;
}

Ax = (Rec_Data[1] << 8) + Rec_Data [0];
Ay = (Rec_Data[3] << 8) + Rec_Data [2];
Az = (Rec_Data[5] << 8) + Rec_Data [4];

//en mg
Ax = Ax /4 / 4 * 0.976 ; // Je divise par 4 pour +/-2G = 4g de différence et le 0.976 est le coefficient de sensibility
Ay = Ay /4 / 4 * 0.976 ;
Az = Az /4 / 4 * 0.976 ;

Total = sqrt( (Ax*Ax) + (Ay*Ay) + (Az*Az) );

Angx = asin(Ax / Total) * 180 / 3.1415;
Angy = asin(Ay / Total) * 180 / 3.1415;
Angz = acos(Az / Total) * 180 / 3.1415;

View_Angx = Angx;
View_Angy = Angy;
View_Angz = Angz;

View_Ax = Ax;
View_Ay = Ay;
View_Az = Az;

}

[umfred]

l'attraction terrestre c'est 9.8N/kg au niveau de la mer
printf("%f",Val_float) pour afficher un float
tu fais 2 divisions successives par 4 avant de multiplier par 0.976. est-ce normal?
Tu as un exemple de valeurs (mesures + résultats obtenus) à nous montrer ? Si tu regardes à chaque étape les valeurs calculées, tu trouveras peut-être ton loup
Le composant est dans quel axe par rapport au PCB (parallèle aux bord de celui-ci? ou de travers auquel ca, son axe est à prendre en compte aussi

[dje8269]

Bonjour umfred,

Pour le printf , je pense que mon µC à du mal avec les virgules flottantes, il s'agit d'un STM332F030 . Un petit joueur en gros.
Les calculs se font bien en debug, mais l'affciahge ne veut pas .

Oui j'ai divise deux fois par 4 , une fois pour le delta de "G" +/-2 = delate de 4 et car je me suis rendu compte que j'étais en 12 bits au lieu de 14 bits , j'ai donc tenté de rediviser par 4 ( ou décaler de 2 vers la droite). Je ne suis pas trop sur de mon coup.

le composants est classiquement monté sur le PCB parallèle aux bords de carte.

J'ai péter tout mon code pour revenir à l'essentiel du départ a savoir connaitre simplement l'orientation. j'ai fais un petit écart pour calculer l'angle mais cela est plus compliqué que prévu , alors je suis revenu à mon niveau .

Je pense que soit un problème de formule, soit une mauvaise compréhension de ma part surtout avec les types de variables les signes et non signés , les float etc...
La dessus mon µC n'arrive pas faire une fonction atan2(x,y) . lol.

Voici un exemple de valeur lu quand le pcb est a plat sur la table.

A droite tu as les valeurs lues.
On va clairement l'axe z subit la pesanteur avec 1g ( 1047mg) et les deux autres axes presque a 0
Sans titre.jpg


Et voici une autre vue avec le PCB sur la tranche
les axes y et z sont à 0 ( ou presque) et on voit clairement l'axe des x à -971 , soit -1g.

Sans titre2.jpg

[gts2]

Bonjour,

Vous avez converti en 16 bits (avec votre <<8), donc le maxi est à 2^15=32768 (pas 2^16 à cause du signe)

Donc votre mesure de 0x4310 sur z soit 17168 correspond à 17168/32768 de la pleine échelle, et comme la pleine échelle est 2g
cela donne Az=Az/2^15*2*0,9676 avec prise en compte du facteur de sensibilité, cela donne 1,022 g ; raisonnable.

[dje8269]

Merci gts2,

effectivement je pense que les mesures sont bonnes. C'est la conversion qui est plus délicate pour déterminer un angle a partir des valeurs brutes.

a force de mesure je crois en déduire une certaines linéarité des valeurs si on tourne au tourne d'un seul axe. pouvez vous me confirmer cela ?

je m'explique.

Supposons la capteur à plat sur mon pcb sur la table.

L'axe des x est environ à 0 ( on imagine hein...)
Maintenant je lève ma carte à 90° mon axe des x passe à environ 17000 ( en brut) c'est normal et parfait
Si maintenant j'incline ma carte à environ 45° la valeur est de 8500 environ soit la moitié de 17000 et 45° la moitie de 90°

Tout cela si les autres axes n'ont pas bougé bien entendu.

je pourrais donc "grossièrement" estimé un angle comme cela ? a condition que la carte soit toujours bien a plat quelque soit son orientation.

[gts2]

accel.pdf

Dans la position initiale, on mesure sur x g et sur y 0
Si on tourne de 45° autour de z, x devient x', y devient y', et on mesure sur x et sur y de l'ordre de 12000.

Vos calculs de trigo sont corrects (à la définition précise près de ce que vous appelez Angx,Angy,Angz). Voir par ex. : analog.com

[umfred]

Comme évoqué par gts2, les valeurs des octets lus sont forme un mot de 16 bits en complément à deux, donc tu as le bit de signe à prendre en compte.
la valeur de Ax=-971, donne avec tes formules (avec la calculatrice windows), un angle de -80.67°, donc ce n'est pas si mauvais que ça.
Que te donnent les calculs d'angles de ton programme pour ce cas ?

[dje8269]

Désolé pour le temps de réponse, j'attendais de recevoir mon chip car j'ai grillé le précédent par inadvertance. Je reviens très vite sur ce post !

[dje8269]

Bonsoir ici,

Je suis de retour après quelques péripéties hardware.

Bon je ne m'en sors pas avec mon module. Impossible d'obtenir un angle.

Je pense que les valeurs les sont correctes c'est moi qui les convertis mal certainement.

La carte est à la verticale sur la table.
Quoi que je fasse l'angle "Z" reste à 90.

Je peux éventuellement décomposer les calculs si vous en avez besoin pour voir on le probléme apparait ?
N'ayant pas le niveau suffisant en math, j'avance à l'aveugle et au pifometre !

Voici mon code avec une simulation.

[jiherve]

bonsoir,
pour les fonctions trigo en fixe voir CORDIC.
JR

[dje8269]

Par acquis de conscience cela peut servir a d'autre voici un code qui fonctionne.

void LIS2DW12_Read_Accel()
{

    RawAccelData raw;
    uint8_t Rec_Data[6];
    float x_norm, y_norm, z_norm;

    // Lecture des 6 registres de données (X,Y,Z sur 16 bits)
    HAL_I2C_Mem_Read(&hi2c1, LIS2DW12_ADDR, 0x28, 1, Rec_Data, 6, 100);

    // Conversion des données brutes en int16_t (signé)
    raw.x = (int16_t)((Rec_Data[1] << 8) | Rec_Data[0]);
    raw.y = (int16_t)((Rec_Data[3] << 8) | Rec_Data[2]);
    raw.z = (int16_t)((Rec_Data[5] << 8) | Rec_Data[4]);

    // Conversion en g
    float x = (float)raw.x * SENSITIVITY; 		// SENSITIVITY=  0.000244f
    float y = (float)raw.y * SENSITIVITY;
    float z = (float)raw.z * SENSITIVITY;

    // Normalisation vectorielle
    float magnitude = sqrtf(x*x + y*y + z*z);

    x_norm = x / magnitude;
    y_norm = y / magnitude;
    z_norm = z / magnitude;

    // Calcul du pitch avec compensation Z
    pitch = (int16_t)(atan2f(-x_norm, sqrtf(y_norm*y_norm + z_norm*z_norm)) * (180.0f / M_PI));

    // Calcul du roll avec compensation Z
    roll = (int16_t)(atan2f(y_norm, z_norm) * (180.0f / M_PI));