Atmos

Un petit peu en retard, mais très bon anniversaire.

Bravo pour ce rover, c'est vraiment magnifique, suberbe travail, vous êtes vraiment de pros

Merci Mike,

Il me semblait bien que c'était ici le problème, mais je ne savais pas comment faire. (sans le smartDelay, le GPS ne fonctionne pas)

J'ai modifié mon code et cela fonctionne pas trop mal. Certainement à amélioré.... mais c'est bon

// ----------------------------------------------- Include
#include <Moteurs.h>
#include  <Gestion.h>

// ----------------------------------------------- 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 minDistance     = 10000;
  float angleAtMinDist  = 0;
  float distOld         = 0;

  int val = 0;
 
  float Distance[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
  float Angle[]    = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
  bool  Ok[]       = {0, 0, 0, 0, 0, 0};
  String A[]       = {"Distance FA : ", "Distance FD : ", "Distance DR : ", "Distance AR : ", "Distance GA : ", "Distance FG : "};

  #define FA 0
  #define FD 1
  #define DR 2
  #define AR 3
  #define GA 4
  #define FG 5

  #define FACE 360
  #define FACD  45
  #define DROI  90
  #define ARRI 180
  #define GAUC 270
  #define FACG 315
  #define CONS 4      // Constante

// ----------------------------------------------- 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;
  unsigned long currentTime  = 0;
  unsigned long previousTime = 0;
#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;

// ***********************************************************************
//                    SETUP
// ***********************************************************************
void setup()
{
#ifdef 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("Initialization COMPAS Failed");
#endif
    while(1);
  }
#endif

//************************************************************************ SDCard
#ifdef SDCARD
  if (!SD.begin(chipSelect))
  {
#ifdef DEBUG
    Serial.println("Initialization SD Failed");
#endif
    return;
  }
#ifdef DEBUG
  Serial.println("Initialization SD Ok");
#endif
#endif
}

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

  Autonome();

#ifdef AFFICHE
  Affiche();
#endif

#ifdef SDCARD
  currentTime = millis();
  if ((currentTime - previousTime) > 3000)
  {
    previousTime = currentTime;
     if (VR.distByOP > 0)           // Distance parcourue
    {
         AssigneGpsCom();
         MakeBuffer();
    }
  }
#endif
}

// ***********************************************************************
//                    AUTONOME
// ***********************************************************************
// *********************************************************************** Autonome
void Autonome()
{
  if (VR.distFA < 300) Serial.println("Stop Avance");
  else  Serial.println("     - Avance");

  if (VR.distAR < 300) Serial.println("Stop Arriere");
  else  Serial.println("     - Avance");
}

// ***********************************************************************
//                    FONCTIONS LIDAR
// ***********************************************************************
// *********************************************************************** Lidar
void AssigneDistances()
{
  while (val != 5)
  {
    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)

      if (distance > 10)
      {
         val = GetLidar(distance, angle, quality);
      }
    }
    else
    {
      analogWrite(RPLIDAR_MOTOR, 0);

      rplidar_response_device_info_t info;

      if (IS_OK(lidar.getDeviceInfo(info, 100)))
      {
        lidar.startScan();
        analogWrite(RPLIDAR_MOTOR, LIDAR_speed);
        delay(1000);
      }
    }
  }
  if (val == 5)
  {
    val = 0;
    return;
  }
}

// *********************************************************************** Lidar
int GetLidar(float dis, float ang, byte qua)
{
    if (ang <= FACE && ang > (FACE - CONS))
    {
      if (!Ok[FA])
      {
        Distance[FA]  = dis;
        VR.distFA     = dis;
        Angle[FA]     = ang;
        Ok[FA]        = 1;
      }
    }
    if (ang <= FACG && ang > (FACG - CONS))
    {
      if (!Ok[FG])
      {
        Distance[FG]  = dis;
        VR.distFG     = dis;
        Angle[FG]     = ang;
        Ok[FG]        = 1;
      }
    }
    if (ang <= GAUC && ang > (GAUC - CONS))
    {
      if (!Ok[GA])
      {
        Distance[GA]  = dis;
        VR.distGA     = dis;
        Angle[GA]     = ang;
        Ok[GA]        = 1;
      }
    }
    if (ang <= ARRI && ang > (ARRI - CONS))
    {
      if (!Ok[AR])
      {
        Distance[AR] = dis;
        VR.distAR    = dis;
        Angle[AR]    = ang;
        Ok[AR]        = 1;
      }
    }
   if (ang <= DROI && ang > (DROI - CONS))
     {
      if (!Ok[DR])
      {
        Distance[DR] = dis;
        VR.distDR    = dis;
        Angle[DR]    = ang;
        Ok[DR]        = 1;
      }
    }
   if (ang <= FACD && ang > (FACD - CONS))
     {
      if (!Ok[FD])
      {
        Distance[FD] = dis;
        VR.distFD    = dis;
        Angle[FD]    = ang;
        Ok[FD]        = 1;
      }
    }


  if (Ok[FA] && Ok[FG] && Ok[GA] && Ok[AR] && Ok[DR] && Ok[FD])
  {
    Ok[FA] = 0;
    Ok[FG] = 0;
    Ok[GA] = 0;
    Ok[AR] = 0;
    Ok[DR] = 0;
    Ok[FD] = 0;
    return 5;
  }
  else return 0;
}

Ouais..., Merci pour les vos infos sur la logiques de votre code, mais mes neurones vont avoir de la peine.

Oui, merci à tous pour votre accueil et à tous les participants.

ça été une de mes premières voitures TT bleu métallisé. La BMW était plus grosse et surtout plus lourde.

Autrement merci pour les infos des composants.

Magnifique, joli rover, après mes élucubrations actuelles, j'en fabriquerai certainement un.

En tout cas bravo, continue.

Regarde peut être le forum Taranis

https://frskytaranis...ssible-a-binder

Bon courage

Oui, tu as tout as fait raison, il est très difficile de trouver des clubs d'aéromodélisme (les drones en font partie) qui acceptent la pratique du drones.
 
Cela montre, malheureusement, l'ouverture d'esprit des vieux aéromodélistes. (dont je fait parties)
 
Mais, il y en as. Cherche...

Salut Oracid,

Plus je lis tes messages, plus je me rends compte que je ne suis pas le seul à vouloir m'affranchir de ces logiciels où tu rentre des coordonnées et que après IL fait tout sans que tu ne fasse plus rien et que tu ne comprends rien.

Lorsque j'ai débuté avec les drones, j'avais acheté le Blade 350 QX de chez Horizon Hobby qui avait un RTH assez fantastique. A chaque fois il revenait se poser à 50 cm. maximum de son point de décollage. Leur logiciels de vols devait être très performant. Pour le reste, ce n'était pas ce que je recherchais ni pour apprendre à piloter, ni pour avancer un peu dans la compréhension des techniques.

Je me suis donc lancer dans la conception et la fabrication de drones.
De 2 " à 10 " une petite trentaine, équipés de BetaFlight et de caméras analalogiques puis HD. Avec lesquels je fait du LR, mais, jamais aucun n'a réussi à se poser (cela vient de BetaFlight), il revient vers le pilote, tu l'entend et cela te permet de te poser en vue direct, où avec les lunettes si tu avait perdu la vidéo.

C'est suite à ces expériences, que comme je te l'ai déjà dis, j'essaye de programmer des rovers qui doivent se rendre d'un point A à un point B, après s'être affranchis des murs, haies, et autre obtacles.
Ce qui n'arrive pas avec un drones, tant qu'il n'y as pas de collines ....

Salutations à tous.

Bonjour à tous,

Depuis ma présentation le 4 novembre 2020, (une année...) j'ai avancé un petit peu.

Je vous présente mon dernier Rover

Chassis     : Base Prowler

Moteur       : Moteurs du Prowler

Contrôleur : Sabertooth

Carte         : Arduino Mega

Capteurs   :

Face             :  MAXSONAR

Face droite   :  VL53LOX

Face gauche : VL53LOX

Droite            : SharpIR

Gauche        : SharpIR

Ne me demandez pas pourquoi ces capteurs (je les ais presque tous essayé), simplement sur ce modèle ils fonctionnent convenablement.

La configuration ci-dessus lui permet de rouler dans une pièce avec de nombreux obstacles, sans jamais les heurter et à trouver la sortie.

J'y ai ajouter un Compas, un Gps, un écran Lcd et un lecteur de carte Sd.

Avec cette configuration, il est capable (le code est amélioré presque tout les jours) de rejoindre un point GPS, malgré les murs, arbres, haies, plantes ect.

Je ne vous cache pas que je dois de temps en temps, l'aider un peu car il s'est coincé sous une plante, qu'il n'a pas suffisamment détecté.

J'ai oublié de dire que j'ai également implémenté une fonction télécommandé avec un récepteur FrSky, et un retour vidéo en HD avec un système DJI AirUnit.

Je n'utilise pas cette option, rigolo un moment, sans intérêt.

Salutation à tous.