Un œil, un seul : Le Tf-Luna

Pourquoi un Tf-Luna ?

Pour pouvoir se déplacer en autonomie, un robot doit avoir une perception minimale de son environnement. Pour R2Ddemi, il doit détecter les obstacles devant lui afin de pouvoir agir en conséquence et tenter, par exemple, de contourner cet obstacle.

Le robot a besoin d'un œil en quelque sorte  😉 (toute proportion gardée !).

Un simple interrupteur placé à l'avant du robot et muni d'une moustache  sert à détecter un obstacle mais seulement quand on rentre en contact avec cet obstacle. Pas d'anticipation possible.

On peut également imaginer une caméra à l'avant du robot mais c'est une solution plus coûteuse et plus complexe. Il faut avoir les moyens d'interpréter les images, et disposer des ressources matérielles et logicielles pour le faire.  Je ne pense pas qu'un Arduino est la capacité  de le faire à moins d'avoir une caméra qui embarque le traitement d'image et ne restitue que quelques informations (j'en ai vu sur le web). J'espère pouvoir y réfléchir un jour.

Les capteurs de distance sont une bonne alternative. Ils sont relativement simples à utiliser, et assez bon marché.

Le principe est très simple :  Si je mesure une distance entre  l'obstacle et moi de moins de X centimètres alors....J'arrête, je tourne, je fais demi-tour, etc...

J'ai choisi le Tf-Luna parce qu'il apporte une bonne précision pour un prix raisonnable. Précision que n'ont pas les capteurs à ultrason par exemple ou d'autres Lidar low cost.

Quand je parle de précision, ce n'est pas tellement la précision de la mesure de distance qui m'intéresse mais plutôt celle du cône de  détection (2° voir ci-dessous).

J'ai monté le Tf-Luna sur une tourelle (déplacée par un servomoteur), ce qui permet de faire des mesures de distances sur un secteur de 180°.

J'obtiens ainsi une pseudo photographie de ce qui se trouve devant le robot et d'en déduire une nouvelle trajectoire en cas d'obstacle proche.

J'aborderai cette partie plus tard.

Description du Tf-Luna

Le Tf-Luna est un LIDAR, Laser infra-rouge de type "Time Of Fligth" (Calcul du temps de vol). Il permet de mesurer la distance qui le sépare d'un objet placé devant lui avec une assez bonne précision et pour un prix raisonnable.

Voici ces principales caractéristiques :

La distance maxi mesurable est de 8 mètres mais je n'ai pas réalisé de tests de précision à cette distance.  Pour R2Ddemi, une distance de 2 à 3 mètres est, pour l'instant, largement suffisante.

Ce qui est appréciable est le cône de détection qui est de 2°.  A 1 mètre la précision est donc d'environ 3.5cm. Ce qui est plutôt bien pour l'utilisation que j'en fait.

On peut utiliser ce composant en liaison UART (Liaison série "Classique" avec broches RX et TX) ou en I2C.

L'avantage du bus I2C est que l'on ne mobilise que 2 broches (SDA et SCL) pour tous les composants I2C alors qu'une  liaison UART nécessite autant de paires de broches que de composants.

Un composant I2C possède une adresse qui lui est propre et c'est par cette adresse que le dialogue se fera entre l'Arduino et  le composant.

Pour en savoir plus sur I2C, c'est ici.

J'ai choisi le mode I2C, je ne détaillerai donc que ce mode.

Le brochage

Pour l'alimentation, pas de difficultés :

• Broche 1 sur 5 volts
• Broche 4 sur la masse

J'ai choisi d'utiliser le bus I2C pour communiquer avec l'Arduino, donc la broche 5 est mise à la masse.

J'ai laissé la broche 6 "En l'air".

Pour les broches 2 et 3  : Attention !!!!!!

Si vous lisez bien le datasheet ci-dessus, vous verrez : Communication Level - 3.3v.

Donc pas question de relier ces deux broches directement sur les broche SDA et SCL du microcontrôleur Arduino MEGA, qui délivre du 5v, au risque d'endommager le TF Luna. Certains microcontrôleur délivrent du 3.3v en niveau logique. Vérifiez bien la tension des niveaux logiques de votre matériel.

Pour une MEGA il faut donc convertir la tension des niveaux logiques avec : Un convertisseur de niveaux logiques 😀

Et bien sûr, avoir une alimentation de 3.3 volts. Pour R2Ddemi, ayant au moins deux composants nécessitant du 3.3v, j'ai utilisé un régulateur ajustable comme celui-ci pour convertir les 7.4v de la batterie en 3.3v

On obtient la tension de sortie souhaitée en réglant un (tout) petit potentiomètre.

A défaut, l'Arduino Mega possède une sortie 3.3 v. Il est sans doute possible de l'utiliser, mais je n'ai pas fait le test.

Pour le convertisseur, j'ai utilisé celui-ci : Convertisseur de 4 niveaux logiques 2595 bidirectionnel (Un lien pour exemple Convertisseur bidirectionnel)

Le brochage est assez simple : 

Les broches identifiées par un L (Low) reçoivent ou émettent du 3.3v, celles identifiées par un H (High) du 5v.

Les broches LV et HV sont à alimenter respectivement en 3.3 et 5v.

Les quatre autres broches sont les niveaux logiques à convertir.

Nous en avons deux à convertir : SDA et SCL (Puisque nous sommes en I2C).

Broche 2 du Tf-Luna (SDA en 3.3v) sur L1 du convertisseur

Broche 3 du Tf-Luna (SCL en 3.3v) sur L2 du convertisseur

Broche H1 du convertisseur sur SDA (en 5v) de la carte Arduino

Broche H2 du convertisseur sur SCL (en 5v)de la carte Arduino

Voilà, le Tf-Luna est branché.

A ce niveau, je vous conseille de téléverser le code i2c_scanner (il se trouve dans les exemples de l'IDE Arduino "Wire" ou sur le web ).

C'est une code très simple, mais très utile, qui va tenter pour chaque adresse I2C (de 1 à 127 ) d'entrer en communication avec le composant I2C identifié par cette adresse.

S'il ne parvient pas à entrer en communication (pas de composant ou composant mal branché ou défectueux) , il n'affiche rien. S'il y parvient il affiche l'adresse.

Donc si l'adresse du Tf-Luna (0x10 par défaut) s'affiche c'est qu'il est opérationnel, sinon c'est qu'il y a un problème de branchement.

Si le Tf-Luna est dirigé vers une source de lumière importante (une fenêtre, par un beau soleil, par exemple) , la mesure ne pourra pas être prise ou sera faussée.

Un peu de programmation

Le mode de communication choisi étant I2C, il nous faut la bibliothèque "Wire"

#include <Wire.h> 

Les variables à déclarer sont les suivantes 

// Tf Luna
uint16_t DistCm     = 0; //distance
uint16_t Amp        = 0; // signal strength
uint16_t Temp       = 0; // temperature
uint16_t TStamp     = 0; // timeStamp
uint16_t Erreur     = 0; // Erreur
const byte TfLuna = 0x10; //Adresse I2C du capteur

Dans le setup du programme, il faut initialiser la communication :

  Wire.begin();

J'ai créé cette fonction (à partir d'un code trouvé pour le capteur "Tf-mini", si j'ai bonne mémoire) : 

boolean MesureDistLuna(uint8_t TfLunaAddress)
{
  // Lire les 5 premieères informations (10 octets) sur le capteur Tf-Luna
  
  Wire.beginTransmission(TfLunaAddress);
  Wire.write(0x00); // Adresse début lecture

  if (Wire.endTransmission(false) != 0) {
    return (false); //Sensor did not ACK
  }
  Wire.requestFrom(TfLunaAddress, (uint8_t) 10 ); // lire 10 octets 

  if (Wire.available()) {
        uint8_t Buffer = Wire.read();
        DistCm = Buffer; //octet faible Distance
        Buffer = Wire.read();
        DistCm |= Buffer << 8; //octet fort distance
        Buffer = Wire.read();
        Amp = Buffer; // Amp 
        Buffer = Wire.read();
        Amp |= Buffer << 8; //Amp
        Buffer = Wire.read();
        Temp = Buffer; // Temperature
        Buffer = Wire.read();
        Temp |= Buffer << 8; // Temperature
        Buffer = Wire.read();
        TStamp = Buffer; // Time Stamp
        Buffer = Wire.read();
        TStamp  |= Buffer << 8; // Time Stamp
        Buffer = Wire.read();
        Erreur = Buffer; // Erreur
        Buffer = Wire.read();
        Erreur  |= Buffer << 8; // Erreur
  }
  else
  {
    Serial.println("Pas de donnée à lire");
    return (false);
  }
  return (true);
}

Pour prendre une mesure de distance, il suffit d'utiliser cette fonction de cette façon :

OK = MesureDistLuna(TfLuna);

OK est une variable à créer (et à nommer à votre guise)  de type "boolean". Elle sera à "Vrai" si une mesure a été prise, ou "Faux" si le capteur n'a pas pu prendre de mesure.

TfLuna est l'adresse I2C du composant Tf-Luna. Cette variable a été déclarée ci-dessus.

La distance lue sera stockée dans la variable globale DistCm déclarée ci-dessus. L'unité de mesure est le centimètre !

Vous remarquerez que l'on peut obtenir d'autres données (température, TimeStamp...). Je ne les ai pas utilisées ni même testées. Pour gagner en place mémoire et en temps processeur, on peut modifier la fonction et enlever la lecture des données inutiles.

Voilà, j'espère que cet article vous sera utile. Amusez vous !