Boussole à inclinaison compensée et calibration mémorisée

Bonjour,

Je cherche à avoir un cap et des inclinaisons de l'IMU pour utiliser avec un esp32 sur un voilier.

La calibration doit être mémorisable car la boussole ne doit pas nécessiter à chaque redémarrage une calibration et c'est nécessaire aussi pour la valeur de la gîte du voilier.

Entre les capteurs un peu documentés sur le web mais plus fabriqués et ceux actuellement en vente mais sans documentation je suis perdu.

Un budget max de 30 euros car j'ai vu que certains capteurs ont des prix astronomiques et en n'ayant pas des frais de port et de douane exorbitants....

Je ne suis pas un expert mais sur un bateau il vaut mieux un GPS. Avec les courants et le vent, le Cap d'une boussole (l'axe du bateau) n'est pas forcément représentatif de là où vous allez.

un IMU solidairement attaché au bateau pourra donner effectivement l'inclinaison transversale (gite / bande) avec un des programmes que l'on trouve un peu partout pour les angles d'Euler

La central d'inertie ne devrait pas te donner justement la dérive ?

Je suis étonné que tu ne trouve pas de datasheet, sur les sites de vente dédié comme digi-key ?
Tu as un exemple de composant qui t'intéresse qui n'a pas de datasheet ?

Deux réponses :

  1. un gps donne la route sur le fond et un compas permet de savoir la direction du bateau et c'est cette dernière qui est utile pour règler les voiles, j'aurai les deux GPS et compas.
  2. Je n'ai pas de circuit défini pour l'instant, et les imu donnent les caractéristiques pour connaître les données accéléromètre; gyroscope et magnétiques mais pas de code pour un compas à inclinaison compensée ni de calibration mémorisée hors c'est ce qui m'intéresse car je suis incapable de le faire.
    Les codes trouvés se rapportent à des circuits qui ne sont plus en vente.

Du coup ce n'est pas un problème de documentation ?
Je ne comprends pas trop ce que tu veux dire ou cherche en fait.

Tu veux une librairie qui calcule ce que tu cherche à partir des données de l'accéléromètre, gyroscope, magnétisme ?

Excusez ma naiveté, mais que se passe-t-il si votre IM et ses magnetometres sont solidement vissés à la coque du bateau , maintenu plat (et pour rendre les choses simples, l'axe des X est vers l'avant de la nef):
le champ magnetique suivant X sera:
Mx = Ter * cos(capMagnetique) + PerturbX
et suivant Y, l'autre axe horizontal
My = Ter * sin(capMagnetique) + PerturbY

  • Ter est le module du champ magétique terrester horizontal

  • PerturbX (rep.Y) sont les perturbations liées au bateau -bouts de ferraille aimantés- et à l'IMU mal étalonné -mais un peu en usine).

Si le bateau fait un demi tour complet (capMagnetique devient capMagnetique + pi), il "suffit" de faire la moyenne (ou la demi somme) des mesures suivant chaque axe pour connaître les perturbations liées à l'IMU et la ferraille du bateau: ce sont deux nombres reels, qui peuvent être assez facilement stockés dans les kilooctets du système de fichiers de l'ESP32.

Si vous faites des quarts de tour, vous pouvez verifier si les échelles/facteurs multiplicatifs des deux axes "horizontaux" sont les mêmes (normalement, c'est fait en usine)
Cela me semble une façon simple de corriger les biais (liés en partie à des bouts d'aimants) des magnétomètres (en faisant l'hypothèse que la composante verticale du champ magnetique terrestre est faible)...

quaternion_compass_new_v8_Version fr.ino (82.4 KB)

Je reconnais un amateur de "Signé Furax" sur Europe numéro 1 à l'époque...
Mon plaisir en rentrant de l'école d'écouter les épisodes avec les ravages du Gruyère qui tue...

J'ai bien compris le principe de la boussole à inclinaison compensée : le magnétomètre donne avec trois valeurs x, y et z la direction du Nord magnétique et avec la gravité on peut en déduire la direction que donnerait une boussole posée à plat alors que le capteur lui change d'assiette continuellement.

Je suis incapable de coder la chose, surtout que chaque circuit a besoin d'être calibré pour prendre en compte sa fabrication et les "masses en fer" qui l'entoure.

J'ai tenté d'utiliser un mpu9250 mais les bibliothèques trouvées sont bugguées.

J'ai trouvé un instructable qui semble faire l'affaire après calibration (en pièce jointe) mais il reste qu'il doit être démarrer à chaque fois à plat, chose impossible sur un voilier.

Donc si quelqu'un est capable de compléter le programme pour mémoriser la calibration à plat, je suis preneur.

Sinon avec quel circuit actuel peut-on trouver le code pour avoir une boussole à compensation d'inclinaison qui pourrait aussi donner roulis et tangage sans calibration à chaque redémarrage ?

Il faudrait que vous indiquiez ce que vous entendez par bugguées, quelles bibliothèques vous avez essayées pour détecter des bugs (pas forcément essayées, d'ailleurs:la lecture de code peut, très rarement, suffire)
Ensuite, j'ai l'impression que votre carte devrait avoir au moins un bouton, pour signaler au démarrage si on est en mode "calibration" ou en mode "normal" (peut être deux boutons, si on choisit une calibration ultra simpliste consistant à faire une roration de 180 degrés au bateau "à plat" -je crois que les téléphones portables ayant, pour des raisons liées au salut d'âmes, un magnétomètre -oriente des prières- ont une calibration analogue-: un bouton pour une orientaion donnée)

  • En mode calibration, il calculerait les corrections additives sur les d.eux axes horizontaux (c'est minimaliste) et les stockerait -c'est classique-
  • en mode normal, une fois lues les deux (ou plus, mais il faut une programmerie plus complexe) corrections, il les appliquerait systématiquement avant de calculer le cap magnétique du bateau.

Quelques questions "en vrac"
avez vous déjà une IMU?
comptez vous, dans votre budget, les afficheurs? (vu la charge mentale liée à la conduite d'un batiau, il me semble que les afficheurs doivent être lisibles... ça peut être cher)

envisagez vous de brancher un GPS sur votre ESP (pour comparer: ça compliquerait la programmerie, mais ça peut être interssant -ou pas-)

Je ne perds pas mon temps à retrouver les bibliothèques qui n'ont pas fonctionnées :slight_smile:
Pas besoin de bouton : si vous aviez lu le programme vous auriez compris que c'est inutile et que donc je n'ai que peu d'espoir de voir une réponse à ma question sur une mémorisation de la calibration de départ actuelle pour les données tangage et roulis.
fr

Effectivement, le programme que vous avez lié en PJ n'utilise pas de bouton ni de stockage des valeurs sur disque.
Il replace ça par une procedure d'étalonnage, suivie de gravure "en dur" dans le code (nécessite d'avoir un PC ou un Rpi pour reprogrammer... et de ne pas faire de fautes de frappe...)
Les procédures d'étalonnage (réétalonne les 9 capteurs en "offset" et "scale factor"; ça fait 18 reals) sont par contre plus sophistiquées que ce que j'envisageais comme point de départ (offset sur deux axes).
En passant, quelques questions:
avez vous testé le code mis en PJ?
y avez vous trouvé des bizarreries?
(nota: je sais que 1300 lignes de code, fûssent elles assez bien commentées, sont abominables à mettre dans les blocs de ce forum dédiés au code; -et à lire sur un téléphone-; mettre en PJ n'est pas mieux : peu de gens prennent la peine/peuvent télécharger; reste le lien vers le site original, qui pourrait être plus qu'utile avec un peu de chances)

si vous savez où est la fonction qui donne les paramètres à sauver c'est assez simple à modifier en utilisant la bibliothèque Preferences pour sauvegarder les données

voici un modèle de code

#include <Preferences.h>
Preferences preferences;

struct {
  int   calibration1;
  float calibration2;
  long  calibration3;
} etalonnage;

void imprimerCalibration() {
  Serial.print("calibration1 = "); Serial.println(etalonnage.calibration1);
  Serial.print("calibration2 = "); Serial.println(etalonnage.calibration2);
  Serial.print("calibration3 = "); Serial.println(etalonnage.calibration3);
}

void calibration() {
  preferences.begin("calibration", false);
  // preferences.clear(); // à décommenter une fois si vous voulez oublier la calibration

  if (preferences.getBool("calibrationOK", false)) {
    // la calibration avait déjà été effectuée
    Serial.println("la calibration avait déjà été effectuée");
    etalonnage.calibration1 = preferences.getInt("calibration1", 0);
    etalonnage.calibration2 = preferences.getFloat("calibration2", 0);
    etalonnage.calibration3 = preferences.getLong("calibration", 0);
  } else {
    // il faut faire la calibration, ici simulée avec des nombres aléatoires
    Serial.println("Premier usage, on effectue la calibration");
    etalonnage.calibration1 = random(-100, 101);
    etalonnage.calibration2 = random(-100, 101) / 47.0;
    etalonnage.calibration3 = random(-10000, 10001);

    // puis on effectue la sauvegarde pour la prochaine fois
    preferences.putInt("calibration1", etalonnage.calibration1);
    preferences.putFloat("calibration2", etalonnage.calibration2);
    preferences.putLong("calibration", etalonnage.calibration3);
    // et on crée une entrée pour se souvenir que la calibration a été effectuée
    preferences.putBool("calibrationOK", true);
  }
  imprimerCalibration();
  preferences.end();
}

void setup() {
  Serial.begin(115200);

  calibration();
}

void loop() {}

on utilise une clé spéciale du nom calibrationOK pour savoir si les données de calibration ont été déjà stockées. Si oui on ne fait que les lire, si non on effectue la calibration avec le process standard (ici simulé avec des nombres aléatoires) et on enregistre les valeurs sous forme de clé/valeur (utiliser la bonne fonction putXXX() en fonction du type XXX de votre variable) et on écrit la clé spéciale calibrationOK à vrai pour le prochain boot.

chargez le code ci dessus. au premier lancement vous verrez

Premier usage, on effectue la calibration
calibration1 = 32
calibration2 = -0.09
calibration3 = 7749

puis si vous rebootez (faites un reset de l'ESP32)

la calibration avait déjà été effectuée
calibration1 = 32
calibration2 = -0.09
calibration3 = 7749

➜ on a bien relu les valeurs

une fois qu'on a compris le principe, au lieu de s'ennuyer à sauver chaque champ de la structure, on peut sauver la structure elle même en binaire avec

putBytes(const char* key, const void* value, size_t len)

et la relecture se faite avec

getBytes(const char* key, void * buf, size_t maxLen)

ce qui fait que l'on peut simplement rajouter autant de champs que l'on veut dans la structure, elle se sauve et se recharge d'un bloc.

Le programme a été testé et aux erreurs de masse en fer dues à la proximité de ma tour il fonctionne pour la boussole, et si on place à un angle de 45 ° la platine au départ cela donne des valeurs ayant 0 quand on remet la platine dans la même position.

Le lien vers l'instructable est dans les premières lignes de la source

Je sais utiliser preferences mais ce que j'ignore c'est quelle valeur sauvegarder quand on démarre à plat

Je suis désolé de dire ça, mais tu n'ai pas vraiment très claire sur ce que tu recherche :frowning:
Donc ton soucis n'est pas du tout sur la mémorisation de la calibration ?
J'avoue que j'ai dû mal à comprendre ton soucis, si tu sais sauvegarder à 45°, quel est le problème de le faire à 0° ?

Postez un lien vers le fichier source qui ne soit pas un téléchargement (github?)

J'ai du mal à me faire comprendre...
Le programme a besoin de calibrer le côté boussole, par une option dans le programme qui recueille des données, ces données sont ensuite intégrées dans le programme.
Cela semble fonctionner
MAIS

Une fois ces données intégrées si on veut connaître les angles de roulis et tangage il faut qu'au démarrage le circuit soit sur un plan horizontal, car le programme prend les origines tangage et roulis avec les valeurs du démarrage.

Si on démarre le circuit sur un plan qui a une inclinaison de 30° en y par exemple ce sera cette inclinaison qui sera considérée comme 0° pour les y

Le circuit se trouvant sur un voilier qui peut ne pas être au port mais en mer et donc avoir de la gîte prendra comme origine non pas un plan horizontal mais la gîte.

Ma question : comment repérer dans le programme les valeurs de départ du programme pour le tangage et le roulis sur plan horizontal, et ensuite les intégrer dans le programme afin qu'elle servent et que le circuit n'ait pas besoin de démarrer sur un plan horizontal.

Pour un programmeur plus doué que moi regarder ce qui se passe dans le programme pour les données gyro et accéléro doit être possible, les sortir en port série puis au lieu qu'elles soient mesurées par l'IMU au démarrage les prendre et les intégrer ensuite comme c'est fait pour les données de la boussole.

Ainsi au lieu de s'étalonner sur une position horizontale à respecter on utiliserait toujours le bon démarrage.

Non, je crois qu'on a bien compris

je lis le forum en ce moment sur mon iPhone, je ne peux pas télécharger votre fichier attaché du post 7 donc je ne peux pas voir ce qui est fait.

➜ vous regardez dans le code ce que fait la fonction de calibrage. Quelle variables sont initialisées à la fin de la procédure. Ce sont les variables que vous voulez sauvegarder la première fois et relire au tout début du code.

C'est cela l'erreur :wink:
Un pdf sur un serveur serait-il utilisable sur un iphone ?
http://fr.photo.free.fr/mpu9250.pdf

trop compliqué pour mon niveau

  1. je n'aime pas windows/microsoft ni android/Google (et ne me parlez pas de Facebook et autres)
  2. je suis très Apple et Linux pour de nombreuses raisons techniques et éthiques (avis personnel, je ne cherche pas la discussion sur ce point qui serait hors sujet ici)
  3. Je n'aime pas télécharger des choses sur mon appareil, surtout en provenance de sources inconnues
  4. (le plus important) je suis en vadrouille et le meilleur appareil pour lire le web est celui qu'on a avec soi.. Dans le cas présent juste mon iPhone ou mon Apple Watch donc.

Donc le PDF ne va pas m'aider.

Au vu de vos questions, vous n'avez clairement pas écrit le code de référence, il doit venir de quelque part sur le web non ? pouvez vous partager ce lien d'origine ?

Ce ne sera pas d'une grande aide non plus. C'est un instructables

et le code est dans un fichier rar à télécharger.

ah bon, ben quand j'aurais accès à mon Mac je jetterai un oeil