22 réponses à ce sujet

[dakota99]

Bonjour,

 

Je souhaiterais guider un robot bimoteur grâce à une camera AI Huskylens.

La cible se trouverait à 20 mètres devant le robot et celui-ci se dirige sur la cible.

C'est en intérieur ou en extérieur (éclairage)

 

J'ai fait différents essais notamment avec les Qrcodes mais dans ce cas la portée est limitée à 2/3 mètres.

 

J'ai choisi d'utiliser le mode Object tracking : la première phase est l'apprentissage. On montre l'objet à la camera.

Ensuite dès que l'objet est reconnu dans le champ de vision, la camera envoie les coordonnées de l'objet sur l'image.

Ca fonctionne bien mais pour des petites distances de 5/6 mètres avec des cibles raisonnables de la taille d'une feuille A4.

 

Je voudrais mieux comprendre quels sont les différents paramètres qui permettent à l'AI de reconnaître l'objet.

- éclairage

- la couleur de l'objet

- la taille de la cible

 

L'idée serait d'utiliser une cible lumineuse qui pourrait être visible même par faible luminosité.

 

Qu'en pensez-vous ?

Avez-vous déjà utilisé de type de camera dans ce contexte ?

 

 

 

[Oracid]

Oui, actuellement, j'utilise la caméra Huskylens comme suiveur de ligne avec un quadrupède. Cela fonctionne plutôt bien.

Il y a pas mal de vidéos sur le Tracking avec cette caméra, mais 20m, cela me parait beaucoup.

Peut-être, pourrais-tu envisager de mette une zoom devant la caméra. En tout cas, ton sujet m'intéresse beaucoup.

Bon courage.

[Sandro]

Bonsoir,

 

Tu veux faire quoi? Guider le robot vers une cible unique (par exemple la station de recharge), ou avoir plusieurs cibles.

 

Si tu veux une seule (ou 3-4) cibles, alors une solution facile pourrait être les lumières vives : tu détecte la tache la plus vive en bleu, violet, orange, ...

 

Sinon, pour ce qui est des QR codes, c'est pas optimal, mais globalement, plus tu as de pixels, moins tu as de porté de détection (et bien sur, plus la cible est grosse, plus tu la voie de loin). Sinon, si tu es prêt à quiter la Huskylens pour une caméra+micro-ordinateur, alors je te conseilles de passer sur les AruCo Tag (ou les April Tag, ou les AR Tag), qui sont optimisés pour la détection de loin (ils ont moins de pixels, et un contour noir bien reconnaissable). Plus tu prendra une caméra haute résolution, avec un temps d'exposition si possible court (global shutter est l'optimal), et si possible avec un champ de vision étroit, plus tu pourra détecter les tags de loin. Pour ma part, avec une caméra 2K plutôt grand angle, je détectais des AR-tags de 25*25cm à 10 à 20m de distance. Sur un autre projet, j'arrivais à détecter un tag de 1.5*1.5m à 30-40m de distance avec une caméra de bien plus faible résolution (720p ? je ne suis plus sur)

 

 

Pour le zoom, avec la Husklens, est-ce que ça ne vas pas "casser" la calibration (et donc donner des positions complètement fausses)? À moins qu'on puisse la recalibrer.

Si c'est un zoom réglable (ie motorisé), il est quasi-impossible de le calibrer proprement, donc on n'aura pas de position précise. Mais si le but est simplement de se diriger vers la cible, alors je suppose que ça doit être faisable.

[Mike118]

en caméra intelligente comme la husky lens mais en plus avancée il y a la caméra jevois. Si je ne me trompe pas c'est fait par un français qui est partis aux USA. 
Sinon tu peux prendre un raspberry pi un camera et faire ton traitement...

[Oracid]

Si je ne me trompe pas c'est fait par un français qui est partis aux USA. 

http://jevois.org/

 

Je crois que c'est ce qu'il te faut !

[dakota99]

Oui en effet ça a l'air super intéressant.

Merci pour le lien.

Je vais les contacter

 

Pour la première fois mon robot a fait des va et vient entre 2 cibles placées à 5m de distance.

Ca a l'air de rien comme ça mais quand tout fonctionne bien ç'est magique

Le Lidar fait de temps en temps des fausses lectures et détecte des obstacles qui n'existent pas et donc le robot fait demi-tour "croyant" être arrivé au bout ... il faut savoir écarter les mauvaises données...

 

Voici la cible utilisée que la camera semble apprécier. Il y a sûrement moyen de faire encore mieux. (le fond noir c'est juste pour la photo)

Il me semble qu'un rétroéclairage pourrait permettre une meilleure visibilité de la cible à plus grande distance....

Ou comme mentionné par Sandro des lumières vives, ou points lumineux qui pourraient être visibles de beaucoup plus loin.

 

Une autre piste : dans mon robot j'utilise un Arduino mega et un smartphone Android (qui est sur le robot et qui pilote le robot en fonction des données des capteurs récoltées par l'Arduino Mega) . Je pourrais l'utiliser aussi pour analyser l'image retournée par la camera...

 

 

[dakota99]

http://jevois.org/tutorials/UserRobotCar.html

 

Contrairement à la Huskylens, les cameras Jevois travaillent avec des ArUco markers

[dakota99]

J'ai continué à améliorer le guidage avec la camera Huskylens, j'ai réalisé des mires lumineuses :

des simples croix réalisées avec des rubans led et un petit dimmer.

La camera en mode reconnaissance d'objet les reconnaît à +/- 8 mètres voire plus. (mon living est trop court).

De plus la reconnaissance peut se faire dans une ambiance lumineuse faible.

 

Je souhaiterais que le robot balaye une surface de +/- 10m x 10m. Le guidage par mire lumineuse ma paraît tellement efficace que je me demande s'il serait pertinent d'utiliser 2 mires mobiles motorisées :

L'axe de déplacement serait défini par 2 mires.

Pour le premier axe le robot est guidé sur la première mire.

Lorsque le robot arrive au bout de l'axe, il fait demi-tour et vise la seconde mire pour revenir au point de départ.

Ensuite la première mire se déplace de 30 cm et ainsi de suite.

Bien sûr il faut fabriquer 2 mires mobiles qui se déplacent quand le robot s'en approche. (détection par ultrasons).

Mais cela me semble en valoir la peine.

[Oracid]

Si les mires sont fixées sur des cordes à rideaux de 10m de long, cela me semble faisable.

Par contre, si les mires sont fixées, chacune sur un véhicule roulant, alors il me semble que cela va être difficile à gérer.

Il faut aller en ligne droite, gérer le déplacement de chaque robot-mire. Bref, deux robots supplémentaires.

[Mike118]

J'ai continué à améliorer le guidage avec la camera Huskylens, j'ai réalisé des mires lumineuses :

des simples croix réalisées avec des rubans led et un petit dimmer.

La camera en mode reconnaissance d'objet les reconnaît à +/- 8 mètres voire plus. (mon living est trop court).

De plus la reconnaissance peut se faire dans une ambiance lumineuse faible.

 

Je souhaiterais que le robot balaye une surface de +/- 10m x 10m. Le guidage par mire lumineuse ma paraît tellement efficace que je me demande s'il serait pertinent d'utiliser 2 mires mobiles motorisées :

L'axe de déplacement serait défini par 2 mires.

Pour le premier axe le robot est guidé sur la première mire.

Lorsque le robot arrive au bout de l'axe, il fait demi-tour et vise la seconde mire pour revenir au point de départ.

Ensuite la première mire se déplace de 30 cm et ainsi de suite.

Bien sûr il faut fabriquer 2 mires mobiles qui se déplacent quand le robot s'en approche. (détection par ultrasons).

Mais cela me semble en valoir la peine.

 

 

Pour mesurer la distance entre " deux robots qui t'appartiennent" tu as des solutions qui te permettent d'installer une balise sur chaque robot de sorte à ce que tes deux robots sachent en permanence où est l'autre... Avec ce genre de système tu peux même te passer de ton système de mire... ( Balise UWB ou balises Ultrasons )

[dakota99]

Les robot-mire peuvent être "très" simples. (oui je sais que ce genre de chose est rarement simple)

Ils ne peuvent se déplacer que tout droit.

Un moto-réducteur sur une roue de traction. 2 roues arrière non pivotantes. Un Arduino, un driver. un capteur à ultrasons, une batterie 12V

Ou je récupère 2 voitures à téléguider que j'adapte.

 

Merci Mike118 : je vais regarder du côté des balises ultrasons, ... mais il faut que ça reste un truc que je suis capable de faire ...

[Mike118]

Pour un truc qui ne peut se déplacer que tout droit; les mettre sur un rail (ou un fil) c'est bien   

[dakota99]

Bonjour,

J'ai avancé sur ce projet.

2 robots mires qui se déplacent. Et le robot principal avec le nettoyeur haute pression qui fait des va et vient entre les 2 robots.

Quand le "gros" robot arrive près d'un robot de guidage, celui-ci reçoit une commande en 433 Mhz qui lui demande de se déplacer de 40 cm.

 

 

En intérieur sur des petites distances de 5/6m cela fonctionne.

A l'extérieur c'est moins évident surtout quand la luminosité est forte ...

 

Je vais tenter d'améliorer le système :

- en utilisant plutôt un point lumineux circulaire. Je ne suis pas convaincu que la croix en led soit plus visible de loin.

- peut-être qu'un seul robot de guidage serait suffisant. Le robot principal ferait marche arrière plutôt que de faire demi tour avec tout ce que cela comporte comme imprécision.

- en utilisant une camera Jevois Pro et AruCo tag (Sandro)

- comme proposé par Mike118 l'idéal serait d'utiliser un système de balises ultrasons / Balise UWB ...

 

Bref il y a encore du taf

 

[Oracid]

A l'extérieur c'est moins évident surtout quand la luminosité est forte ...

Oui, mais, au final, est ce que les contrôleurs ZS-X11H suffisent, en terme de puissance ?

[dakota99]

Bonjour

 

Pour l'instant les contrôleurs ZS-X11H conviennent pour le job. Merci pour ton aide Oracid.

 

Je viens d'acquérir une camera Jevois Pro.

L'objectif est de l'utiliser avec des ArUcode pour guider le robot et surtout d'augmenter la portée par rapport à l'Huskylens.

 

C'est un appareil nettement plus complet : Linux Ubuntu avec un paquet de modules. Faut apprendre à maîtriser la bête.

Si qq l'a déjà utilisé avec un Arduino ...

[Oracid]

Je viens d'acquérir une camera Jevois Pro.

Bravo ! J'attends avec impatience ton retour d'expérience.

 

Je mets, ici, la vidéo de présentation et un lien de la société qui la produit, pour ceux que cela pourrait intéresser.

Cette caméra coute, quand même, environ 400€ pour le premier prix et 600€ pour la version plus élaborée.

Tu as eu de la chance d'en trouver une, car actuellement, elle est en rupture de stock. C'est la rançon du succès.

 

http://www.jevois.org/

https://www.jevoisinc.com/

 

[dakota99]

Contexte : j'utilise une camera AI pour guider un robot bimoteur.

Celui-ci se dirige vers une cible qui est posée sur un second petit mobile qui se déplace.

J'ai auparavant utilisé une camera Husky Lens. J'ai d'abord essayé avec des codes barres puis une mire en forme de croix et la fonction object tracking de la camera Husky Lens. Cela fonctionne pour des petites distances de +/- 4m mais la camera est très sensible aux variations de lumière et donc la solution n'est pas convaincante pour des plus grandes distances et surtout pour travailler à l'extérieur.

 

Je suis donc passé sur la camera Jevois Pro. Celle-ci permet de travailler avec des ArUco markers. Ce sont des codes barres simplifiés plus adaptés à la robotique. C'est un appareil tout à fait différent de l'Husky Lens : c'est un petit ordinateur sous Linux sur lequel on branche un écran HDMI, clavier et souris.

On choisit l'application qui nous intéresse : reconnaissance d'objets, de mains, de visages, .... et d'ArUco. La vitesse de détection des ArUco est impressionnante et sans apprentissage.

Après quelques essais à l'extérieur, la camera détecte sans problème un ArUco à 8 mètres sous différentes luminosités.

La connexion avec l'Arduino Mega (port série 2) est très simple VIN GRD RX TX. Voici le code utilisé qui peut à mon avis être optimisé.

La camera envoie la chaîne "T2 cx cy" à 115200 bauds

x = coordonnées en x du centre de l'ArUco marker. -1000 à fond à gauche et 1000 à fond à droite.

Parfois il y a des valeurs tout à fait différentes Exemple 20 fois les valeurs 800 100 puis 0 0. Cela vient sûrement du code.

void jevois() {
  if (millis() - t4 > 500)
  {
    t4 = millis();
    if (inData == "") {cx = 9999;cy = 0;}
     
    while (Serial2.available() > 0)
    {
      char rx = Serial2.read();
      inData += rx; 
      if (rx == '\n')
        {readString = inData; 
         inData = "";
         cm1 = readString.substring(3,7); 
         char carray[cm1.length() + 1]; 
         cm1.toCharArray(carray, sizeof(carray)); 
         cx = atoi(carray); // coordonnées en x 
          
        }
    }
  }
}

A première vue les possibilités sont assez vastes.

 

 

[Mike118]

Si les erreurs reçues sont uniquement des 0 0 ça peut se filtrer assez facilement. 

Je pense que le vrai problème est lié à l'utilisation de la fonction atoi qui n'est pas " safe " et au fait que tu ne vérifies pas l'intégrité de tes données avant d'utiliser la fonction ... 

[dakota99]

Oui le code pourrait être plus optimal.

Je vais tester le robot avec ce code et voir s'il y a beaucoup de données à filtrer.

Pour info voici le code d'un exemple d'une came Jevois pour guider des servos.

Mais je ne comprends pas bien le code au niveau de la réception série. Donc je préfère utiliser un code que je comprends mieux

// JeVois control steering or a pan/tilt head from the output of JeVois modules
//
// We handle messages "T2 <targetx> <targety>", "T1 <targetx>", "PANGAIN <gain>", and "TILTGAIN <gain>".
// targetx and targety are assumed to be in the -1000 ... 1000 range as output by the JeVois Kalman filters.
// Here we only do simple PD control under the assumption that target coordinates have already been filtered upstream.
 
#include <Servo.h>
 
// Pin for LED, blinks as we receive serial commands:
#define LEDPIN 13
 
// Serial port to use: on chips with USB (e.g., 32u4), that usually is Serial1. On chips without USB, use Serial:
#define SERIAL Serial1
 
// Pins for up to two servos:
Servo panservo;
#define PANPIN 3
Servo tiltservo;
#define TILTPIN 5
 
// Initial servo values in degrees:
#define PANZERO 90
#define TILTZERO 90
 
// With updates typically coming in at 60Hz or up to 120Hz, we will often need to move by a fraction of a
// degree. Hence we keep track of the pan and tilt values multiplied by SCALE. For the gains, a gain of 100
// means we will update servo angle by the 0.1*(target value/SCALE) degrees on each update. Higher gains mean
// larger angular updates.
#define SCALE 100
long pangain = 100;
long tiltgain = 100;
long panval = PANZERO * SCALE;
long tiltval = TILTZERO * SCALE;
 
// Buffer for received serial port bytes:
#define INLEN 128
char instr[INLEN + 1];
 
void setup()
{
  SERIAL.begin(115200);
  SERIAL.setTimeout(1000000);
 
  pinMode(LEDPIN, OUTPUT);
  digitalWrite(LEDPIN, LOW);
  
  panservo.attach(PANPIN);
  panservo.write(panval / SCALE);
 
  tiltservo.attach(TILTPIN);
  tiltservo.write(tiltval / SCALE);
 
  // We are ready to rock, disable logs and turn on serial outputs on JeVois platform:
  SERIAL.println("setpar serlog None");
  SERIAL.println("setpar serout Hard");
}
 
void loop()
{
  digitalWrite(LEDPIN, LOW);
  byte len = SERIAL.readBytesUntil('\n', instr, INLEN);
  instr[len] = 0;
  digitalWrite(LEDPIN, HIGH);
 
  char * tok = strtok(instr, " \r\n");
  int state = 0; int targx = 0, targy = 0;
  while (tok)
  {
    // State machine:
    // 0: start parsing
    // 1: T2 command, parse targx
    // 2: T2 command, parse targy
    // 3: T2 command complete
    // 4: T1 command, parse targx
    // 5: T1 command complete
    // 6: PANGAIN command, parse pangain
    // 7: PANGAIN command complete
    // 8: TILTGAIN command, parse tiltgain
    // 9: TILTGAIN command complete
    // 1000: unknown command
    switch (state)
    {
      case 0:
        if (strcmp(tok, "T2") == 0) state = 1;
        else if (strcmp(tok, "T1") == 0) state = 4;
        else if (strcmp(tok, "PANGAIN") == 0) state = 6;
        else if (strcmp(tok, "TILTGAIN") == 0) state = 8;
        else state = 1000;
        break;
        
      case 1: targx = atoi(tok); state = 2; break;
      case 2: targy = atoi(tok); state = 3; break;
      case 4: targx = atoi(tok); state = 5; break;
      case 6: pangain = atoi(tok); state = 7; break;
      case 8: tiltgain = atoi(tok); state = 9; break;
 
      default: break; // Skip any additional tokens
    }
    tok = strtok(0, " \r\n");
  }
 
  // Target coordinates are in range -1000 ... 1000. Servos want 0 ... 180.
  // We also need to negate as needed so that the servo turns to cancel any offset from center:
  if (state == 3 || state == 5)
  {
    panval -= (targx * pangain) / 1000;
    if (panval < 5 * SCALE) panval = 5 * SCALE; else if (panval > 175 * SCALE) panval = 175 * SCALE;
    panservo.write(panval / SCALE);
  }
  
  if (state == 3)
  {
    tiltval += (targy * tiltgain) / 1000;
    if (tiltval < 5 * SCALE) tiltval = 5 * SCALE; else if (tiltval > 175 * SCALE) tiltval = 175 * SCALE;
    tiltservo.write(tiltval / SCALE);
  }
}

 

[dakota99]

Bonjour,

La camera Jevois fonctionne très bien. Un ArUco au format A4 est détecté à une distance de 14 mètres.

 

Cependant je cale sur la réception des données envoyées par la camera Jevois.

La chaîne qu'elle envoie est : N2 U6 289 22 131 131

Je dois récupérer la valeur 289 qui est la valeur en x de l'ArUco et 131 qui est sa largeur. (qui permet de déterminer la distance de la cible).

Evidemment la longueur de la chaîne varie  (Exemple : N2 U6 1 230 450 450)

Voici le code que j'ai adapté :

void jevois() {
 if (millis() - t4 > 250)
  {
   t4 = millis();
   byte len = Serial2.readBytesUntil('\n', instr, INLEN);
   instr[len] = 0;
   char *tok = strtok(instr, " \r\n");
   state = 0;cy = 0;
   //===========================================================
   while (tok)
   {
    state ++;
    switch (state)
     { case 1: if (strcmp(tok, "N2") != 0){break;}
       case 3: cx = atoi(tok); {cy=1;break;}
       case 5: width = atoi(tok); break;
       default: break; // Skip any additional tokens
     }
     tok = strtok(0, " \r\n");
   } // while (tok)
   //===========================================================
   Serial.print(" cx:");Serial.print(cx);
   Serial.print(" width:");Serial.println(width);
  }// if
}

Parfois la chaîne reçue est correcte mais parfois l'Arduino reçoit :

 

N2 U9 21 131 130
N2 U6 289 2N2 U6 289 21 131 130
N2 UN2 U6 289 21 131 130
N2 U6 289 2N2 U6 289 21 131 1N2 U6 289 21 131 130

N2 UN2 U6 289 21 132 130

 

Dans un langage plus convivial (Windev ) je chercherais la première occurrence de N2 à partir de la droite.

Pour n'avoir que ceci : N2 U6 289 21 131 130

Puis boucle avec strtok pour avoir chaque valeur.

Je vérifie que valeur 1 = N2, valeur 2 U6
 

Mais bon en C++ c'est moins évident pour moi.

Je vais tester avec lastindexof() mais il a sûrement une méthode plus simple pour une communication série classique.

 

Si quelqu'un y voit plus clair ... merci pour votre aide.