25 réponses à ce sujet

[Atmos]

Bonsoir à tous,

 

J'ai une interrogation ?

 

J'ai plusieurs rovers avec des capteurs de distances (US, TOF, Lidar, ect) avec lesquels je trouvent les valeurs pas toujours corrects.

 

Il se trouve en plus que j'ai l'impression que mes Arduino Mega rament un peu à gérer tous mes capteurs (capteurs de distance, Gps, compas, ect..)

 

J'ai fait des tests avec un RPLidar, mais je ne suis pas certain qu'il puisse remplacer à lui seul 5 capteurs indépendant. (trop de points à gérer)

 

Je pensais ajouter un Raspberry ou un Jetson Nano pour gérer, au dessus de l'Arduino (j'ai déjà fait quelques tests avec les deux (mais sans connexion avec l'arduino... mais une chose à la fois..)

 

Je viens vers vous utilisateurs avertis de la robotique afin de vous demander conseils.

 

Si vous avez des conseils ? je suis à l'écoute.

 

Merci

 

 

[Sandro]

Bonjour,

 

Pour les valeurs incorrectes, il y a 4 possibilités :

1) un problème de lecture des capteurs (pour certains capteurs, ça peut être une conséquence d'un manque du puissance du microcontroleur/micro-ordinateur, mais ça peut aussi venir du code en soit)

2) de défauts des capteurs

3) d'une mauvaise alimentation des capteurs

4) d'erreurs dues au phénomène physique des capteurs :

- US : un obstacle lisse qui est trop tourné par rapport à la l'avant du capteur ne sera pas détecté (sur un robot, on avait 5 capteurs US à l'avant du robot : impossible pourtant de détecter un carton d'emballage de 1*1*1m placé à 1m devant le robot s'il est tourné à 45° (un carton 20*20*20 étant détecté sans problème s'il est parallèle au robot)

- US : perturbé pas d'autres sources d'UV, entre autre le vent

- US : fort cross talking (si 2 capteurs émettent à peu près en même temps, risque de mesurer le signal émit par l'autre capteur)

- ToF : selon la techno, peut être très sensible à la matière de l'obstacle (entre autre les capteurs "SHARP" sont selon mes tests complètement inexploitables pour mesurer une distance si la cible n'a pas toujours la même matière)

 

Sinon, un lidar, c'est très gourmand en ressources. Selon le type de données envoyées (données individuelles ou trame d'un coup), ça peut être quasi indispensable d'y dédier une arduino séparée pour reconstruire la trame. Là, il faudra nous en dire plus sur le lidar utilisé, ainsi que le nombre de mesures par seconde.

 

 

Sinon, l’architecture avec laquelle j'aime bien travailler, c'est un micro-ordinateur (rapsberry Pi, Odroid, Jetson (j'avais utilisé le Xavier AGX, bien plus puissant que le Nano), ...) tournant sous linux avec ROS, qui regroupe les données de tous les capteurs. Certains capteurs (caméra, éventuellement Lidar, ...) sont branchés directement au micro-ordinateur (ie les capteurs avec beaucoup de transferts de données et une interface haut niveau (série/USB/caméra)), et le reste des capteurs sont reliés à un ou plusieurs micro-controleurs (arduinos, STM32, ...) qui communiquent avec l'ordinateur par USB

[Atmos]

Merci Sandro,

 

C'est exactement les analyses que j'avais constatés (surtout que mes rovers fonctionnent en extérieur, j'ai essayé presque tout les capteurs, de prix correct) le TFMini plus est actuellement celui qui me semble le plus juste.

 

Je fait des tests avec le RPLidar sur un banc de test, il ne fait que m'afficher distance Face, Droite, Gauche et Arrière, je pense que ce n'est pas son but, c'est plus rapide (avec Arduino) de mettre 4 TFMini plus.

 

Je pense que pour aller plus loin, tu me conforte dans l'idée d'avoir un couple Raspberry ou Jetson + Arduino. Mais là, je n'y connait rien du tout.

 

Bon dimanche.

[Sandro]

Pour le RPLidat, je ne sais pas comment tu l'exploite, mais tu peux en tirer bien plus d'information que les distances Face, Droite, Gauche et Arrière : même la première version peut te donne 8000 mesures/s (donc 800 à 4000 mesures/tour selon la vitesse de rotation choisie).

Donc contrairement à 4 TFMiniPlus, tu n'as pas juste la distance dans 4 directions, mais dans chaque direction tu as la distance jusqu'à l'obstacle le plus proche (en supposant qu'il soit à la bonne hauteur). Bien sur, ça fait beaucoup de données à traiter ensuite (soit tu les réduits à quelques données, par exemple la position de l'obstacle le plus proche, soit tu exploite l'ensemble des données, par exemple pour de la cartographie).

 

Ce qui est le plus compliqué, c'est de détecter les petits obstacles (par exemple un poteau) :

- avec un capteur directif, comme par exemple le TF Mini Plus, tu as de fortes chances de passer à coté et de ne pas détecter l'obstacle. Par contre, ce genre de capteurs est très bien pour des applications comme suivre un mur, où on sait que c'est un gros obstacle et où on veut la distance sur un axe précis)

- avec un capteur US, tu détectera facilement des obstacles, car les capteurs US ont un grand cône de détection. Par contre, les obstacles mal orientés sont mal ou pas détectés, le vent peut fausser les mesures, on risque de détecter le sol, et la fréquence d'acquisition est très faible (d'autant plus si on a plusieurs capteurs, car pour éviter le crosstalk il faut le plus souvent les utiliser à tour de rôle)

- avec un Lidar 2D (type RPLidar, tu détecte les obstacles tout autour, y compris des obstacles assez fins s'ils sont proches (angle de moins d'un degré pour le RPLidar A1, encore moins pour les successeurs (0.225° pour le A3)). Le principal inconvénient (outre le prix et la quantité de données à traiter) est que la mesure se fait à une hauteur déterminée (celle du lidar), et que tous les obstacles plus haut ou plus bas ne seront pas visible.

- avec un Lidar 3D : tu as plusieurs faisceaux lasers superposés verticalement qui tournent ensemble : ça élimine le problème de non détection des obstacles bas. Par contre, l'énorme problème est le prix (hors de portée de 99.9% des amateurs). Si tu es riche, alors c'est clairement la meilleur solution, sinon oublie.

- avec une caméra stéréo (ou deux caméras, ou éventuellement 1 caméra + IMU + beaucoup de puissance de calcul), tu peux obtenir la profondeur. Au boulot, on avait eut de bon résultats pour la détection d'obstacle (mais insatisfaisant pour détecter d'éventuels trous dans le sol) avec la Zed2 de Stereolabs (mais c'est 450€ la caméra, et il te faut un bon ordi derrière (on utilisais la Jetson Xavier AGX, je penses qu'une Jetson Nano est le stricte minimum)). Il me semble qu'il y a certaines caméras qui génèrent l'image de profondeur en interne, et qui demandent donc beaucoup moins de puissance de calcul de la part de l'ordi. A priori, ça devrait pouvoir se faire "manuellement" avec 2 caméras bon marché, mais j'ai jamais essayé, et je penses que ça doit pas être évident d'obtenir de bon résultats

[Atmos]

Merci, très intéressant, c'est fou mais lorsque tu commence, tu t'aperçois que tous les capteurs que tu as te donne des valeurs aléatoires et tu en commande d'autres et c'est pareil.

 

Donc, il faut y mettre le prix et surtout être un professionnel de la programmation... ce qui n'est pas mon cas. Je suis novice.

 

Suite de mes tests avec le RPLidar, je n'arrive pas à gérer tout ces points.

[Sandro]

Pour les capteurs, aucun ne donne en soit une "valeur aléatoire" : chacun mesure un phénomène physique donné, avec les limitations qui vont avec. La part vraiment aléatoire (le "bruit", ie la variation du signal dans des conditions strictement identiques) est souvent assez faible pour ne pas poser de problème.

Mais il est vrai qu'en pratique trouver le bon capteur n'est pas forcément facile, et que souvent il faut combiner plusieurs capteurs pour cumuler les avantages de tous.

Par exemple, un robot pourra cumuler un Lidar2D pour le repérage, la cartographie, la détection des obstacles au loin pour déterminer la trajectoire et la détection des obstacles prêts s'ils sont assez hauts. La limitation : on peut facilement rater un obstacle bas et rentrer dedans : on peut donc compléter par des capteurs Ultrason, qui sont très bon pour détecter des obstacles à petite distance (grand cône de détection, possibilité d'en placer plusieurs près du sol). En temps normal, avec les capteurs US, on risquerait de rater un obstacle à 45° : mais celui-ci sera très probablement détecté par le LIDAR, donc on pourra quand même l'éviter. Ainsi, avec la combinaison Lidar+US, on arrive à détecter quasiment tous les obstacles. Si jamais on veut encore plus de fiabilités, alors il y a plusieurs options : capteurs de contact "mous" (à condition que le robot puisse s'arrêter en quelques cm), capteurs US en faisceaux croisés, ajout d'un 2nd lidar devant à ras du sol, ...

 

Si tu veux que j'essaye de te conseiller plus sur le/les capteurs à utiliser, il vas falloir que tu nous en dises plus sur le projet (type de robot, type d'obstacles, degré de fiabilité souhaité, capteurs que tu as et budget que tu es prêt à investir en plus)

 

 

Pour le RPLidar :

A priori, il semblerait qu'un arduino permette de gérer un RPLidar (cf : https://github.com/r...rplidar_arduino).

En revanche, je ne penses pas que tu arriveras a gérer autre chose en plus (ou alors il faut gérer très finement le temps réel, ce qui est compliqué).

Donc si tu veux rester sur de l'arduino pur, ce qui a des chances de marcher, c'est d'utiliser deux arduinos qui communiquent : le premier qui gère uniquement le RPLidar et en extrait les infos "clés" (à toi de voir ce qui t'intéresse, ça peut par exemple être la distance et l'angle de l'obstacle le plus proche du robot dans la partie "avant"), qu'il envoi ensuite au second arduino qui gère tout le reste.

Le premier Arduino sera alors un capteur "magique" qui te donne une (ou quelques) infos complexes du type "position et distance de l'obstacle le plus proche", "orientation du mur situé à gauche du robot", ...

 

Si tu veux faire des choses complexes avec les données du Lidar (par exemple de la cartographie), alors tu vas avoir besoin de toutes les données sur un ordinateur relativement puissant (raspberry pi au stricte minimum)

[Mike118]

Avoir des capteurs c'est bien, mais le plus important c'est de savoir quoi en faire / pourquoi on veut les utiliser.

Avec un microcontrôleur type arduino due ( un pic uwb32 ) il est possible de faire du slam sur microcontrôleur avec un seul microcontrôleur dédié aussi bien au lidar, aux codeurs, à l'asservissement, à l'imu et au traitement des données. 

 

 

Du coup la même chose est possible avec un microcontrôleur comme le teensy 4.1 encore plus performant que le micro-contrôleur utilisé dans cette vidéo.
Mais oui il existe toujours la solution de coupler un mircocontrôleur avec un ordinateur comme un raspberry pi.  Tout dépend de ce qui est souhaité.

[Atmos]

He ben voilà ce qui m'intéresse.

 

Je n'ai pas de projet particulier, ce que j'aimerai c'est apprendre ce que je ne connait pas.

 

Mes rovers fonctionnent assez bien, mais ce que je veux c'est qu'ils fonctionnent parfaitement.

 

Actuellement, ils se plantent (pas toujours, mais trop souvent) dans un mur, une haie, un arbre, une plante basse, un escalier...) et je vois bien que si je veux ajouter des capteurs ou des fonctions complémentaires le temps de réponse est trop long.

 

Oui, j'aimerai des conseils pour intégré un Raspberry ou un Jetson et d'autres capteurs éventuels. Raspberry que je pourrai ajouter à mes Arduino.

 

Le budget... est fonction de mes envies...

[Atmos]

Mike,

 

Oui j'ai déjà vu de nombreuses fois ce que tu me montre, mais c'est complexe pour moi. J'essaye de comprendre et écrire pas à pas, en commençant par le plus simple.

[Atmos]

Mike,

 

C'est toi qui à écrit le programme de gestion et de cartographie de ton robot ?

[Mike118]

Mike,

 

C'est toi qui à écrit le programme de gestion et de cartographie de ton robot ?

 

Oui. On est deux sur ce projet. Dans la vidéo c'est chez moi =)

[Atmos]

Bravo Mike,

 

Le robot se souvient de la cartographie, c'est LA solution pour s'orienter.

[Atmos]

Bonsoir à tous,

 

Je ressort ce sujet que j'avais abandonner, vu que j'avais toujours des "résultats aléatoires" malgré vos conseils.

 

J'ai remis le RPLidar sur le banc d'essai... mais j'ai toujours les soucis, et je pense que mon RPLidar est depuis toujours défectueux.

 

J'ai chargé l'exemple simple_connect (sans modifications importantes sauf serial3 et Serial.print" sur un Arduino Mega et comme il y as plusieurs mois même soucis.

 

Je précise qu'il m'affiche toujours les même valeurs, alors que je déplace des obstacles devant et jamais d'autres angles.

 

Dites moi ce que vous en pensez ?

 

simple_connect.ino

---------------------

#include <RPLidar.h>

// You need to create an driver instance
RPLidar lidar;

#define RPLIDAR_MOTOR 5 // The PWM pin for control the speed of RPLIDAR's motor.
                        // This pin should connected with the RPLIDAR's MOTOCTRL signal
                       
                        
void setup() {
  // bind the RPLIDAR driver to the arduino hardware serial
  lidar.begin(Serial3);
  Serial.begin(115200);  
  // set pin modes
  pinMode(RPLIDAR_MOTOR, OUTPUT);
}

void loop() {
  if (IS_OK(lidar.waitPoint())) {
    float distance = lidar.getCurrentPoint().distance; //distance value in mm unit
    float angle    = lidar.getCurrentPoint().angle; //anglue value in degree
    bool  startBit = lidar.getCurrentPoint().startBit; //whether this point is belong to a new scan
    byte  quality  = lidar.getCurrentPoint().quality; //quality of the current measurement
    
Serial.print("Distance = ");
Serial.print(distance);
Serial.print(" Angle    = ");
Serial.println(angle);
    
  } else {
    analogWrite(RPLIDAR_MOTOR, 0); //stop the rplidar motor
    
    // try to detect RPLIDAR...
    rplidar_response_device_info_t info;
    if (IS_OK(lidar.getDeviceInfo(info, 100))) {
       // detected...
       lidar.startScan();
       
       // start motor rotating at max allowed speed
       analogWrite(RPLIDAR_MOTOR, 255);
       delay(1000);
    }
  }
}

--------------------

 

Résultat

 

21:35:00.574 -> Distance = 7320.25 Angle    = 238.84
21:35:00.574 -> Distance = 3144.00 Angle    = 228.78
21:35:00.621 -> Distance = 3080.00 Angle    = 228.78
21:35:00.621 -> Distance = 3737.25 Angle    = 200.86
21:35:02.120 -> Distance = 7001.25 Angle    = 232.89
21:35:02.120 -> Distance = 6737.50 Angle    = 20.09
21:35:02.120 -> Distance = 7320.25 Angle    = 238.84
21:35:02.120 -> Distance = 3144.00 Angle    = 228.78
21:35:02.120 -> Distance = 3080.00 Angle    = 228.78
21:35:02.120 -> Distance = 3737.25 Angle    = 200.86
21:35:03.620 -> Distance = 7001.25 Angle    = 232.89
21:35:03.620 -> Distance = 6737.50 Angle    = 20.09
21:35:03.620 -> Distance = 7320.25 Angle    = 238.84
21:35:03.620 -> Distance = 3144.00 Angle    = 228.78
21:35:03.620 -> Distance = 3080.00 Angle    = 228.78
21:35:03.620 -> Distance = 3737.25 Angle    = 200.86
21:35:05.120 -> Distance = 7001.25 Angle    = 232.89
21:35:05.120 -> Distance = 6737.50 Angle    = 20.09
21:35:05.120 -> Distance = 7320.25 Angle    = 238.84
21:35:05.120 -> Distance = 3144.00 Angle    = 228.78
21:35:05.167 -> Distance = 3080.00 Angle    = 228.78
21:35:05.167 -> Distance = 3737.25 Angle    = 200.86
21:35:06.667 -> Distance = 7001.25 Angle    = 232.89
21:35:06.667 -> Distance = 6737.50 Angle    = 20.09
 et toujours pareil

[Mike118]

C'est pas en plein milieu de l'acquisition qu'il faut envoyer des prints .... 
Je pense que c'est ça le problème ... 

Essaye un truc du genre : 

 

#include <RPLidar.h>

// You need to create an driver instance
RPLidar lidar;

#define RPLIDAR_MOTOR 5 // The PWM pin for control the speed of RPLIDAR's motor.
                        // This pin should connected with the RPLIDAR's MOTOCTRL signal
                       
                        
void setup() {
  // bind the RPLIDAR driver to the arduino hardware serial
  lidar.begin(Serial3);
  Serial.begin(115200);  
  // set pin modes
  pinMode(RPLIDAR_MOTOR, OUTPUT);
}

void loop() {
  if (IS_OK(lidar.waitPoint())) {
    float distance = lidar.getCurrentPoint().distance; //distance value in mm unit
    float angle    = lidar.getCurrentPoint().angle; //anglue value in degree
    bool  startBit = lidar.getCurrentPoint().startBit; //whether this point is belong to a new scan
    byte  quality  = lidar.getCurrentPoint().quality; //quality of the current measurement
   if(distance < 300) {
    Serial.print("Distance = ");
    Serial.print(distance);
    Serial.print(" Angle    = ");
    Serial.println(angle);
   }
  } else {
    analogWrite(RPLIDAR_MOTOR, 0); //stop the rplidar motor
    Serial.println("Lidar not ok");
    
    // try to detect RPLIDAR...
    rplidar_response_device_info_t info;
    if (IS_OK(lidar.getDeviceInfo(info, 100))) {
       // detected...
       lidar.startScan();
       Serial.println("Starting Lidar");
       // start motor rotating at max allowed speed
       analogWrite(RPLIDAR_MOTOR, 255);
       delay(1000);
    }
  }
}

Cet exemple ne fait afficher un point que si tu as un obstacle très proche. 

Après la lib que tu utilises n'est pas aussi bien que les autres codes déjà partagés sur le forum ... 
Mais bon essaye déjà avec la petite modification que je viens de te faire et ensuite on verra pour faire mieux ... 
En tout ca je n'ai pas encore essayé le code que tu as mis mais ça ne m'étonnerais pas que ta petite mega ne soit pas assez rapide pour faire l'acquisition et l'affichage sur le moniteur série en même temps au milieu de l'acquisition... (à vouloir spammer le moniteur série pendant l'acquisition ça ne m'étonnerait pas que tu " casses " l'acquisition.  Normalement on récupère le gros paquet de données puis on les affiches alors que là tu essayais d'afficher chaque bout de données au fur et à mesure )

[Atmos]

Merci Mike,

 

J'avais déjà essayé de limiter les print, mais sans succès.

 

J'ai essayé ton code, et il y a une amélioration, maintenant il m'affiche

Starting Lidar.

Lidar not ok.

 

On avance

[Atmos]

J'ai vainement fait plein de tests, (avec UNo, MEGA, Teensy, avec ou sans alimentation séparée) mais sans succès.

 

Avez-vous un lien vers une autre library

 

On n'avance plus.

[Atmos]

Bonjour à tous, Suite...

J'ai changé le RPLidar, maintenant il m'affiche des distances juste et très rapidement, je rappelle, que pour le moment je n'utilise que 6 distances.
Mais, j'ai de nouveau un problème, peut être que l'un de vous pourra me donner une suggestion ou plusieurs.

Le Rover est équipé d'une carte Teensy 4.1, sur laquelle sont branchés les éléments suivant :
Serial2 --> Carte contrôleur moteur Sabertooth
Serial3 --> GPS Beitian BN 880
I2C      --> COMPAS Beitian BN 880
Serial7 --> RPLidar

 

Comme d'habitude je teste chaque éléments seul avant de continuer.
Le Rover fonctionne bien avec le RPLidar, mais dès que j'active le GPS (et / ou) le COMPAS, les distances ne sont plus du tout réelles.
Le GPS et le COMPAS fonctionnent correctement, avec ou sans RPLidar.
J'ai essayé pas mal de modifications sans succès (changé les ports Serial, dans le code, ect.)

 

En ajoutant une Mega pour gérer le GPS et COMPAS, puis transfert sur la Teensy, tout va bien, mais j'aimerai bien comprendre pourquoi et par quel phénomène, dès que j'ajoute un élément tout bascule.

 

Je pense que ce doit être mon code qui récupère les distances ou la library du RPLidar qui pose problème, mais je n'en ai pas d'autre, et je ne sais pas comment récupérer les distances correctement.

Merci à vous

[Mike118]

Peux tu partager : 

A ) le code que tu utilises pour dire que le lidar marche 
B ) le code que tu utilises pour dire que le GPS et compas marche 
C) le code où tu mélanges les deux et qui "ne marche pas " . 

Avant même de voir le code, si tu as des appel à " delay() dans le code B, mais pas de le code A) et que tu en as dans le code C) alors ça peut expliquer pourquoi ton code C ne marche pas ... 
Pour la lecture du lidar il est recommander d'avoir du code non bloquant.

[Atmos]

// ----------------------------------------------- Define
// #define DEBUG
#define AFFICHE
#define GPS
//#define COMPAS
//#define SDCARD

// ----------------------------------------------- Lidar
/*
  vert TX7, blanc RX7, bleu (3)
*/

#include <RPLidar.h>
  #define RPLIDAR_MOTOR 3
  RPLidar lidar;

  const int LIDAR_speed = 255;
//  float distFA, distFG, distDR, distAR, distGA, distFD;
  float minDistance     = 10000;
  float angleAtMinDist  = 0;
  float distOld         = 0;

// ----------------------------------------------- Gps
#ifdef GPS
#include <TinyGPS++.h>
  TinyGPSPlus gps;
  static const uint32_t GPSBaud = 9600;
#endif

// ----------------------------------------------- Compas
#ifdef COMPAS
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_HMC5883_U.h>
  Adafruit_HMC5883_Unified mag = Adafruit_HMC5883_Unified(12345);
#endif

// ----------------------------------------------- SDCard
#ifdef SDCARD
#include <SD.h>
#include <SPI.h>
  File myFile;
  const int chipSelect = BUILTIN_SDCARD;
#endif

// ----------------------------------------------- Variables
struct SValeursRover
  {
    float distFA;
    float distFD;
    float distDR;
    float distAR;
    float distGA;
    float distFG;
    char  Date[12];
    char  Time[12];
    float distToWP;
    float distByOP;
    bool  Pivote;
    float Compas;
    float Degres;
    float Azimut;
    float Latitude;
    float Longitude;
    int   Satellites;
    int   Difference;
  };
  struct SValeursRover VR;

// ----------------------------------------------- Réservoir
  static const double latWay = 44.3951145;
  static const double lonWay =  4.4768838;

#ifdef SDCARD
  unsigned long currentTime  = 0;
  unsigned long previousTime = 0;
#endif

// ***********************************************************************
//                    SETUP
// ***********************************************************************
void setup()
{
#ifdef AFFICHE
  // Affiche
  Serial.begin(115200);

#endif

//************************************************************************ RPLidar
  Serial7.begin(115200);
  lidar.begin(Serial7);
  pinMode(RPLIDAR_MOTOR, OUTPUT);

//************************************************************************ Gps
#ifdef GPS
  Serial3.begin(GPSBaud);
#endif

//************************************************************************ Compas
#ifdef COMPAS
  if(!mag.begin())
  {
#ifdef DEBUG
    Serial.println("Ooops, no HMC5883 detected ... Check your wiring!");
#endif
    while(1);
  }
#endif

//************************************************************************ SDCard
#ifdef SDCARD
  if (!SD.begin(chipSelect))
  {
#ifdef AFFICHE
    Serial.println("initialization failed!");
#endif
    return;
  }
#ifdef AFFICHE
  Serial.println("initialization done.");
#endif
#endif
}

// ***********************************************************************
//                    LOOP
// ***********************************************************************
void loop()
{
  AssigneDistances();

  AssigneGpsCom();

#ifdef AFFICHE
  Affiche();
#endif

#ifdef SDCARD
  currentTime = millis();
  if ((currentTime - previousTime) > 3000)
  {
    previousTime = currentTime;

    // if (VR.distByOP > 0)
    // {
      MakeBuffer();
    // }
  }
#endif
}

// ****************************************************************** GpsCom
void AssigneGpsCom()
{
#ifdef COMPAS
  VR.Degres = Compas();
#endif

#ifdef GPS
  VR.Azimut = Gps();
//  VR.Difference  = Realise(VR.Degres, VR.Azimut);
#endif
}

// ***********************************************************************
//                    FONCTIONS LIDAR
// ***********************************************************************
// *********************************************************************** Lidar
void AssigneDistances()
{
  if (IS_OK(lidar.waitPoint()))
  {
    float distance  = lidar.getCurrentPoint().distance;
    float angle     = lidar.getCurrentPoint().angle;
    bool  startBit  = lidar.getCurrentPoint().startBit;
    byte  quality   = lidar.getCurrentPoint().quality;

    if (distance > 0 && distance < minDistance)
//    if (distance > 0 && quality > 15)
    {
      SelectDistances(angle, distance / 10);
      // Resultat();
// #ifdef COM
//       vR.degres      = Compas();
// #endif
// #ifdef GPS
//       vR.azimut      = Gps();
//       // Difference  = Realise(Degres, Azimut);
// #endif
    }
  }
  else
  {
    analogWrite(RPLIDAR_MOTOR, 0);
    rplidar_response_device_info_t info;

    if (IS_OK(lidar.getDeviceInfo(info, 85)))
    {
       lidar.startScan();
       analogWrite(RPLIDAR_MOTOR, LIDAR_speed);
       delay(1000);
    }
  }
}

// *********************************************************************** Lidar
void SelectDistances(float ang, float dis)
{
    if (ang <= 317.0 && ang > 313.0)
    {
      VR.distFG = dis;
    }
    if (ang <= 272.0 && ang > 268.0)
    {
      VR.distGA = dis;
    }
    if (ang <= 182.0 && ang > 178.0)
    {
      VR.distAR = dis;
    }
    if (ang <= 92.0 && ang > 88.0)
    {
      VR.distDR = dis;
    }
    if (ang <= 47.0 && ang > 43.0)
    {
      VR.distFD = dis;
    }
    if (ang <= 4.0 && ang > 0.0)
    {
      VR.distFA = dis;
    }
}

/*
// *********************************************************************** Lidar

// *********************************************************************** Lidar
// void Resultat()
// {
//   OK = 0;

//   if (distFA > 0 && distFD > 0 && distDR > 0 && distAR > 0 && distGA > 0 && distFG > 0)
//   {
//     vR.FA = distFA;
//     vR.FD = distFD;
//     vR.DR = distDR;
//     vR.AR = distAR;
//     vR.GA = distGA;
//     vR.FG = distFG;

//     OK = 1;

//     distFA = 0;
//     distFD = 0;
//     distDR = 0;
//     distAR = 0;
//     distGA = 0;
//     distFG = 0;
//   }
// }
*/

// ***********************************************************************
//                    FONCTIONS AFFICHAGE
// ***********************************************************************
// *********************************************************************** Affiche
#ifdef AFFICHE
void Affiche()
{
  Serial.println("----------------------");
  Serial.print("Distance FA : ");
  Serial.println(VR.distFA);
  Serial.print("Distance FD : ");
  Serial.println(VR.distFD);
  Serial.print("Distance DR : ");
  Serial.println(VR.distDR);
  Serial.print("Distance AR : ");
  Serial.println(VR.distAR);
  Serial.print("Distance GA : ");
  Serial.println(VR.distGA);
  Serial.print("Distance FG : ");
  Serial.println(VR.distFG);
#ifdef GPS
  Serial.println("----------------------");
  Serial.print("Satellites  : ");
  Serial.println(VR.Satellites);
  Serial.println("----------------------");
  Serial.print("Date        : ");
  Serial.println(VR.Date);
  Serial.print("Time        : ");
  Serial.println(VR.Time);
  Serial.println("----------------------");
  Serial.print("Latitude    : ");
  Serial.println(VR.Latitude, 6);
  Serial.print("Longitude   :  ");
  Serial.println(VR.Longitude, 6);
  Serial.println("----------------------");
  Serial.print("Azimut      : ");
  Serial.println(VR.Azimut);
  Serial.print("Difference  : ");
  Serial.println(VR.Difference);
  Serial.println("----------------------");
  Serial.print("Dist. to WP : ");
  Serial.println(VR.distToWP);
  Serial.print("Dist. By OP : ");
  Serial.println(VR.distByOP);
#endif
#ifdef COMPAS
  Serial.print("Degres      : ");
  Serial.println(VR.Degres);
#endif
}
#endif

//*********************************************************************** Gps
#ifdef GPS
float Gps()
{
  VR.Satellites = gps.satellites.value();
  VR.Latitude   = gps.location.lat();
  VR.Longitude  = gps.location.lng();

  sprintf(VR.Date, "%02d-%02d-%02d", gps.date.year(), gps.date.month(), gps.date.day());
  sprintf(VR.Time, "%02d:%02d:%02d", gps.time.hour(), gps.time.minute(), gps.time.second());

  double courseToDestination =
    TinyGPSPlus::courseTo(gps.location.lat(), gps.location.lng(), latWay, lonWay);

  VR.distToWP = TinyGPSPlus::distanceBetween(gps.location.lat(), gps.location.lng(), latWay, lonWay);

  smartDelay(500);

  if (millis() > 5000 && gps.charsProcessed() < 10)
    Serial.println(F("No GPS data received: check wiring"));

  return courseToDestination;
}
#endif

//*********************************************************************** Gps
#ifdef GPS
static void smartDelay(unsigned long ms)
{
  unsigned long start = millis();
  do
  {
    while (Serial3.available())
      gps.encode(Serial3.read());
  } while (millis() - start < ms);
}
#endif

//*********************************************************************** Compas
#ifdef COMPAS
float Compas()
{
  sensors_event_t event;
  mag.getEvent(&event);

  float heading = -atan2(event.magnetic.y, event.magnetic.x);
//  float heading = atan2(event.magnetic.y, event.magnetic.x);
  float declinationAngle = 0.0;
  heading += declinationAngle;
 
  if(heading < 0)
    heading += 2*PI;
   
  if(heading > 2*PI)
    heading -= 2*PI;

  float headingDegrees = heading * 180/M_PI;
 
  return headingDegrees;
}
#endif

// ***********************************************************************
//                    FONCTIONS SAUVEGARDE
// ***********************************************************************
//************************************************************************ MakeBuffer
#ifdef SDCARD
void MakeBuffer()
{
  String MyBuffer = "";
  String MyBufferTmp = "";

  MyBuffer = MyBuffer + VR.Date;
  MyBuffer = MyBuffer + " " + VR.Time;

  MyBufferTmp = String(VR.Latitude, 7);
  MyBuffer = MyBuffer + " " + MyBufferTmp;

  MyBufferTmp = String(VR.Longitude, 7);
  MyBuffer = MyBuffer + " " + MyBufferTmp;

  MyBuffer = MyBuffer + " " + VR.Difference;
  MyBuffer = MyBuffer + " " + VR.Azimut;
  MyBuffer = MyBuffer + " " + VR.Degres;
  // MyBuffer = MyBuffer + " " + valeursRover.pivote;
  MyBuffer = MyBuffer + " " + VR.distToWP;
  MyBuffer = MyBuffer + " " + VR.distByOP;
  MyBuffer = MyBuffer + " " + VR.distFD;
  MyBuffer = MyBuffer + " " + VR.distFG;
  MyBuffer = MyBuffer + " " + VR.distDR;
  MyBuffer = MyBuffer + " " + VR.distGA;

  FileWrite(MyBuffer);
}

//************************************************************************ FileWrite
void FileWrite(String b)
{
  myFile = SD.open("RoverNew.txt", FILE_WRITE);
 
  if (myFile)
  {
    myFile.println(B);
    myFile.close();

#ifdef AFFICHE
    Serial.println(B);
#endif
  }
  else
  {
#ifdef AFFICHE
    Serial.println("Error opening File");
#endif
  }
}
#endif

[Atmos]

Voici, c'est bien ce que j'avais plus ou moins compris lorsque on en avait parlé, mais là, je bloque et comme je suis borné, j'essaie de comprendre, alors que je pourrai garder l'option Mega et Teensy qui fonctionne bien.

 

Je pense que comme déjà dit, c'est l'acquisition des distances qui posent problème.

 

Je n'ai qu'un code avec des #define

 

Merci Mike