English

Leçons · Leçon S3 · Les capteurs · 40 min

Capteurs intelligents, distance et caméra

Mesure une distance avec un capteur à temps de vol, puis lis où se trouve une cible colorée dans la vue d’un module caméra. Environ 40 minutes, avec un cône de distance et un cadre de caméra que tu peux déplacer.

Deux façons de voir pour une machine

Imagine que tu cries dans une grotte sombre et que tu chronomètres l’écho. Plus l’attente est longue, plus le mur est loin. Les chauves-souris sont célèbres pour se repérer ainsi avec le son. Une caméra fait autre chose : elle capte de la lumière, comme tes yeux, et il faut ensuite que quelque chose décide ce que contient l’image.

Les deux idées existent dans un petit module que tu peux relier à un ESP32. Dans cette leçon, tu vas utiliser :

  1. un capteur de distance qui chronomètre un éclair de lumière pour te dire à quelle distance se trouve quelque chose,
  2. un module caméra qui repère une couleur que tu lui as apprise et te dit où elle se trouve dans sa vue.

Aucun des deux ne te donne des données brutes à trier. Ils font le plus dur à l’intérieur et envoient une réponse courte sur les deux fils I2C de la leçon K5 : un nombre de millimètres, ou la position d’un rectangle.

Deux façons de voir pour une machine Image coupée en deux. À gauche, une main devant une petite carte capteur de distance ; un cône fin de lumière invisible part vers la main et revient, avec une flèche en pointillés dans chaque sens. Légende : chronomètre le trajet : la distance. À droite, une petite carte caméra qui regarde une scène avec une balle colorée, entourée d’un rectangle aux coins épais. Légende : trouve la couleur : où est-elle ? En dessous, les deux cartes sont reliées par les mêmes deux fils, SDA et SCL, à un ESP32. Les deux fils de la caméra passent par un petit adaptateur de niveau, montré plus loin dans le câblage. Chaque module fait le travail difficile à l’intérieur et envoie une réponse courte : un nombre de millimètres, ou la position d’un rectangle. FIG. 1 — DISTANCE ET CAMÉRAaCapteur de distancela lumière partet revientchronomètre le trajet : la distanceréponse : un nombre de millimètresbModule camérarectangletrouve la couleur : où est-elle ?réponse : où est le rectangleSDASCLadaptateur de niveau(voir le câblage de la caméra)ESP32GPIO 21 · 22les mêmes deux fils I2C qu’en leçon K5
Touche le schéma pour l’ouvrir en plein écran.

Distance : le temps de vol

Un capteur à temps de vol (ToF, pour time of flight) envoie de la lumière, détecte le temps qu’elle met à revenir, puis transforme ce temps en distance [1]. Le VL53L0X en est un. Sa lumière est invisible et son faisceau est étroit : il lit la surface juste devant lui [1]. Un sonar, qui fait rebondir du son à la place, couvre un cône plus large [1].

Trois choses à savoir :

  • La portée. Le guide d’Adafruit annonce environ 50 à 1 200 mm [1]. Retiens « de quelques centimètres jusqu’à environ un mètre ». Attends-toi à ce que le nombre bouge un peu : selon la lumière et la distance, il est juste à environ 3 à 12 % près [1].
  • Hors de portée. Quand rien ne peut être mesuré, la lecture n’est pas fiable, et le programme d’exemple affiche « out of range » [3][4].
  • Son adresse. Sur les fils I2C, le capteur répond par défaut à 0x29 [2][3]. Ton scanner de K5 le trouvera là.

Et le capteur à ultrasons bon marché ? Le HC-SR04 est très répandu, mais sa sortie d’écho est en 5 V, et elle ne peut pas aller directement sur une carte comme la tienne [6]. Il lui faut d’abord un pont diviseur ou un adaptateur de niveau. Cette leçon le laisse de côté et utilise le capteur I2C, qui n’a besoin ni de l’un ni de l’autre.

Faisceau étroit, cône plus large Deux cadres vus de dessus, la même scène dans chacun : un capteur à gauche, une boîte droit devant, et un pied de chaise un peu sur le côté. a, le capteur à temps de vol : un faisceau étroit atteint la boîte droit devant lui et manque le pied de chaise. Légende : faisceau étroit. b, un sonar, qui fait rebondir du son : un cône plus large couvre la boîte et aussi le pied de chaise sur le côté. Légende : cône plus large. Angles dessinés pour comparer, pas à l’échelle. FIG. 2 — LARGEUR DU FAISCEAUaTemps de volboîtepied de chaisemanquéfaisceau étroitlit droit devantbSonar (son)boîtepied de chaiseaussi captécône plus largevoit plus sur les côtésAngles dessinés pour comparer, pas à l’échelle.
Touche le schéma pour l’ouvrir en plein écran.

Branche-le et lis-le

Alimente-le en 3V3, même si la carte accepte jusqu’à 5 V [2]. Même raison que dans K5 : sa broche d’alimentation fixe le niveau des signaux I2C, et les broches de l’ESP32 sont faites pour 3,3 V.

Carte distance ESP32 DevKitC
Vin 3V3
GND GND
SDA GPIO 21
SCL GPIO 22

Les GPIO 21 et 22 sont les broches I2C par défaut de l’ESP32 générique [7]. Ajoute une DEL sur la GPIO 16 à travers une résistance de 220 Ω, comme dans la leçon K2, pour montrer « quelque chose est près ».

Câblage S3 : capteur de distance sur 3V3, GND, 21, 22 ; DEL sur 16 Vue plaque d’essai, de dessus. La DevKitC est hors de la plaque, USB à gauche, alimentée par son câble USB ; des fils à embout femelle vont directement sur ses broches. La carte distance à droite a quatre broches étiquetées : VIN, GND, SDA, SCL ; l’ordre des broches change selon les cartes, suis donc les étiquettes. 1 rouge, 3V3 vers VIN : alimente-la par la 3V3, pas par la 5V. 2 noir, GND vers GND. 3 bleu, GPIO 21 vers SDA. 4 jaune, GPIO 22 vers SCL. En dessous, une plaque d’essai tient la DEL : 5 vert, GPIO 16 vers la rangée 3, une résistance de 220 ohms de la rangée 3 à la rangée 7, la grande patte de la DEL, le plus, en rangée 7, sa petite patte en rangée 8 ; 6 noir, rangée 8 vers le rail moins du haut ; 7 noir, le rail moins du haut vers une broche GND de la DevKitC. Seul le rail moins est utilisé. Retire d’abord le cache de protection du capteur. FIG. 3 — CÂBLAGE, CAPTEUR DE DISTANCEENBOOT5VCLKCMDD0D3D1D215132GND0124141627172652518331932GND352134RXVNTXVP22EN233V3GNDcarte distancecapteurVINGNDSDASCL1234l’ordre des broches change :suis les étiquettes+−−+jihgfedcba135781014+220 ΩDEL : grande patte (+) en rangée 7rail − seulement567GND3V316GND2122GND1rouge : 3V3 → VIN (pas 5V)2noir : GND → GND3bleu : GPIO 21 → SDA (données)4jaune : GPIO 22 → SCL (horloge)5vert : GPIO 16 → rangée 3, 220 Ω vers rangée 76noir : − de la DEL (rangée 8) → rail − du haut7noir : rail − du haut → broche GNDAlimente la carte par la 3V3 : sa broche d’alimentation fixe le niveau de SDA et SCL. Retire le cache de protection du capteur.21, 22 et 16 sont sur la rangée du bas : fils à embout femelle directement sur les broches.
Touche le schéma pour l’ouvrir en plein écran.

Installe la bibliothèque Adafruit VL53L0X depuis le gestionnaire de bibliothèques, comme dans K5 [3]. S’il propose d’installer d’autres bibliothèques avec, clique sur « Install all ». Retire d’abord le petit capuchon de plastique de protection du capteur [3]. Puis téléverse :

// Tinker Mission, leçon S3 : distance avec un capteur à temps de vol (carte VL53L0X)
// Câblage (alimente la carte en 3V3, voir leçon K5) :
//   Vin -> 3V3     GND -> GND     SDA -> GPIO 21     SCL -> GPIO 22
//   DEL : GPIO 16 -> résistance de 220 ohms -> longue patte de la DEL ; courte patte -> GND
// Ouvre le moniteur série à 115200 baud. La DEL s'allume quand quelque chose est plus près que NEAR_MM.
// Il faut la bibliothèque « Adafruit VL53L0X » (gestionnaire de bibliothèques).

#include <Wire.h>
#include "Adafruit_VL53L0X.h"

const int SDA_PIN = 21;   // la broche de données I2C habituelle de l'ESP32 DevKitC
const int SCL_PIN = 22;   // la broche d'horloge I2C habituelle de l'ESP32 DevKitC
const int LED_PIN = 16;   // DEL qui montre « quelque chose est près »

const int NEAR_MM = 200;                   // plus près que ça = « près » (200 mm = 20 cm)
const unsigned long READ_INTERVAL = 100;   // une mesure toutes les 100 ms

Adafruit_VL53L0X lox = Adafruit_VL53L0X();
unsigned long lastRead = 0;

void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);
  Wire.begin(SDA_PIN, SCL_PIN);   // démarre le bus I2C sur ces deux broches

  if (!lox.begin()) {             // cherche le capteur à son adresse (0x29 par défaut)
    Serial.println("Sensor not found. Check power, SDA and SCL wires.");
    while (true) {
      delay(1000);                // rien d'autre à faire : on s'arrête ici
    }
  }
  Serial.println("Sensor ready. Move your hand in front of it.");
}

void loop() {
  unsigned long now = millis();

  if (now - lastRead >= READ_INTERVAL) {
    lastRead = now;

    VL53L0X_RangingMeasurementData_t measure;
    lox.rangingTest(&measure, false);   // demande une mesure

    if (measure.RangeStatus != 4) {     // le statut 4 veut dire que la mesure n'est pas fiable
      int distance = measure.RangeMilliMeter;
      Serial.print("Distance (mm): ");
      Serial.println(distance);
      digitalWrite(LED_PIN, distance < NEAR_MM ? HIGH : LOW);
    } else {
      Serial.println("Out of range");
      digitalWrite(LED_PIN, LOW);
    }
  }
}

Télécharger le dossier du croquis (.zip)

Ouvre le moniteur série à 115200 baud. Fais aller et venir ta main. Tu devrais voir quelque chose comme ceci :

Sensor ready. Move your hand in front of it.
Distance (mm): 412
Distance (mm): 188
Distance (mm): 87
Out of range

Comment ça marche : lox.rangingTest(&measure, false) prend une mesure, et le résultat se lit dans measure.RangeMilliMeter [4]. Un RangeStatus égal à 4 signale une mauvaise mesure, donc le programme ne fait confiance qu’aux autres [4]. La DEL s’allume sous 200 mm (20 cm).


Caméra : où est la couleur ?

Un module de vision comme le HuskyLens contient une petite caméra et un processeur. Tu lui apprends quelque chose (un visage, une ligne, une couleur). Ensuite, il te dit où il le voit. En mode reconnaissance de couleur, il dessine un rectangle autour de la couleur que tu lui as apprise [10].

Ton ESP32 demande et reçoit un bloc avec ces nombres [5] :

  • xCenter et yCenter : le milieu du rectangle,
  • width et height : sa taille,
  • ID : quelle couleur apprise c’est. La première que tu apprends a l’ID 1 [5].

Un ID de 0 veut dire « quelque chose est détecté, mais pas appris » [5].

L’erreur par rapport au centre. L’écran de la caméra fait 320 sur 240 pixels [8] : le milieu en largeur est donc vers 160. Soustrais-le :

error = xCenter - 160 (l’erreur)

Une erreur négative veut dire que le x de la cible est plus petit que 160, une erreur positive qu’il est plus grand, et zéro qu’elle est centrée. Déplace ta cible et regarde dans quel sens x grandit sur ta propre caméra. C’est ce nombre qu’un robot utilise pour se tourner vers une cible : tu as vu l’autre moitié dans A2, où un nombre devient un angle de servo.

Essaie ci-dessous, avec le cône sur un onglet et le cadre de la caméra sur l’autre.

Distance par temps de vol (interactif) · Où est la couleur ? Image de la caméra (interactif)
Distance par temps de vol (interactif) Simulation interactive, pas un vrai capteur. Un capteur de distance à gauche envoie un cône de lumière étroit vers la droite, au-dessus d’une règle de 0 à 1400 mm. Fais glisser la boîte vers le capteur ou loin de lui, ou utilise le curseur de distance. La lecture montre Distance (mm) et le nombre, comme le moniteur série ; la DEL sur la GPIO 16 s’allume quand la boîte est plus près que NEAR_MM, 200 mm par défaut. Au-delà d’environ 1200 mm, la zone hachurée, la lecture devient Out of range. simulation, pas le capteurhors de portée200DEL, GPIO 1605001000mm

Simulation du croquis distance, pas un vrai capteur.

Distance (mm): 350DEL sur la GPIO 16 : éteinte
Moniteur série · 115200 bauds
Distance (mm): 350

Une vraie lecture bouge un peu, de quelques pour cent. Portée : environ 50 à 1200 mm.

Voici l’état de départ : les commandes ont besoin de JavaScript.


Branche la caméra et lis-la

Deux choses à régler avant de brancher la caméra.

L’alimentation. Le HuskyLens accepte de 3,3 à 5 V. Son courant typique est de 320 mA à 3,3 V, ou de 230 mA à 5 V, mesuré en reconnaissance de visage, lumière d’appoint éteinte [8]. C’est bien plus qu’une DEL ou qu’un petit capteur, donc ne l’alimente pas depuis la broche 3V3 de la carte. Le fabricant dit qu’on peut l’alimenter par son port USB ou par son connecteur à 4 broches, et qu’il utilise l’USB en priorité si les deux sont branchés [11]. Le plus simple est de lui donner son propre câble USB, relié à un chargeur ou à une batterie externe, avec seulement GND et les deux fils de signal (à travers l’adaptateur de niveau, voir plus bas) vers l’ESP32. Vérifie que l’alimentation est assez puissante, sinon la caméra se comporte mal [11].

Les signaux : toujours par un adaptateur de niveau. Les broches I2C de la caméra sont marquées T (SDA) et R (SCL) sur son connecteur à 4 broches [8]. La caméra est faite pour marcher aussi avec des cartes en 5 V, et le fabricant ne dit pas à quelle tension ces deux fils se trouvent quand elle fonctionne en 5 V par l’USB. Les broches de ton ESP32 sont faites pour 3,3 V : ne prends pas le risque. Mets entre les deux un petit adaptateur de niveau I2C, avec un côté basse tension (LV) et un côté haute tension (HV), comme dans la leçon K5. Une carte à 4 canaux de type BSS138 est la plus courante ; prends-la avec ses broches déjà soudées. Câble-le ainsi :

Adaptateur de niveau Relier à
LV 3V3 de l’ESP32
HV 5V de l’ESP32
GND (des deux côtés) GND de l’ESP32 et - de la caméra
Côté HV, canal 1 T (SDA) de la caméra
Côté HV, canal 2 R (SCL) de la caméra
Côté LV, canal 1 GPIO 21
Côté LV, canal 2 GPIO 22

Laisse le fil + (VCC) de la caméra non branché : entoure son bout de ruban adhésif pour qu’il ne touche rien. La caméra est alimentée par son propre câble USB.

Sur la caméra elle-même, règle le protocole : General Settings > Protocol Type > I2C, puis tourne la molette jusqu’à « Save & Return » et confirme « Yes », sinon le réglage n’est pas gardé [9]. La détection automatique est la valeur par défaut [9], et l’exemple I2C du fabricant choisit I2C [12].

Câblage de la caméra S3 : sa propre alimentation USB, les signaux par un adaptateur de niveau Vue de dessus, sans plaque d’essai. La DevKitC est posée sur la table, USB à gauche, alimentée par son câble USB ; des fils à embout femelle vont directement sur ses broches et sur celles d’un petit adaptateur de niveau I2C à 4 canaux, de type BSS138, acheté avec ses broches soudées. La rangée du haut de l’adaptateur est son côté basse tension, LV, face à l’ESP32 : 1 rouge, 3V3 vers LV ; 2 noir, GND vers le GND côté LV ; 3 bleu, GPIO 21 vers LV1, canal 1 ; 4 jaune, GPIO 22 vers LV2, canal 2. Sa rangée du bas est le côté haute tension, HV, face à la caméra : 5 orange, la broche 5V de la carte vers HV, par son propre fil. Le connecteur 4 broches de la caméra, broches T, R, moins et plus : 6 vert, T, le SDA de la caméra, vers HV1, canal 1 ; 7 bleu, R, le SCL de la caméra, vers HV2, canal 2 ; 8 noir, le moins de la caméra vers le GND côté HV. Les deux broches GND de l’adaptateur sont reliées sur sa carte, donc toutes les masses sont communes. Le fil plus de la caméra, VCC, n’est pas branché : son bout est entouré de ruban adhésif. La caméra a son propre câble USB vers un chargeur ou une batterie externe, avec une note : sa propre alimentation, 230 à 320 mA. Règle le protocole de la caméra sur I2C. L’ordre des broches change selon les adaptateurs : suis les étiquettes. FIG. 4 — CÂBLAGE, CAMÉRA ET ADAPTATEUR DE NIVEAUENBOOT5VCLKCMDD0D3D1D215132GND0124141627172652518331932GND352134RXVNTXVP22EN233V3GNDcaméra (face avant)TR−++ (VCC) : non branché, bout scotchéchargeur USBou batterie externesa propre alimentation : 230–320 mAadaptateur de niveauLV1LV2LVGNDLV3LV4HV1HV2HVGNDHV3HV4côté LV : 3,3 Vcôté HV : 5 V5V : son propre fil, pas de rail5VGND3V3GND2122GND123456781rouge : 3V3 → LV (côté basse tension)2noir : GND → GND, côté LV3bleu : GPIO 21 → LV1 (canal 1)4jaune : GPIO 22 → LV2 (canal 2)5orange : broche 5V → HV (côté haute tension)6vert : T (SDA) de la caméra → HV1 (canal 1)7bleu : R (SCL) de la caméra → HV2 (canal 2)8noir : − de la caméra → GND, côté HVLes deux GND de l’adaptateur sont reliés sur sa carte : toutes les masses sont communes. Protocole de la caméra : I2C.L’ordre des broches change selon les adaptateurs : suis les étiquettes du tien.
Touche le schéma pour l’ouvrir en plein écran.

Aucune bibliothèque à installer. La bibliothèque du fabricant [5][12] s’arrête sur une erreur avec les versions récentes du paquet de cartes ESP32 : ce programme est donc livré avec une copie corrigée, dans un dossier appelé src. Télécharge tout le dossier du programme depuis cette leçon (s’il arrive en ZIP, décompresse-le d’abord), garde le nom de dossier l-s3-color-track, garde src à côté du fichier .ino, et ouvre l-s3-color-track.ino depuis là. Copier seulement le code ci-dessous ne marchera pas.

Apprends-lui une couleur. Tourne la molette de fonction jusqu’à ce que « Color Recognition » s’affiche en haut. Pointe le « + » sur un objet uni, de couleur vive, jusqu’à ce qu’un cadre blanc le sélectionne. Fais un appui long sur le bouton d’apprentissage en t’approchant et en t’éloignant, puis relâche [10]. Si un message te demande s’il faut continuer, attends simplement la fin du compte à rebours [10]. La première couleur apprise reçoit l’ID 1 [10]. La reconnaissance de couleur dépend beaucoup de la lumière de la pièce : garde-la identique [10]. Puis téléverse :

// Tinker Mission, leçon S3 : où est la cible colorée ? (HuskyLens, reconnaissance de couleur, I2C)
// Câblage : à travers un adaptateur de niveau I2C (LV = côté 3V3, HV = côté 5V) : SDA/SCL de la caméra -> HV, LV -> GPIO 21 (SDA) / 22 (SCL), toutes les GND reliées.
//   Alimentation : la caméra demande environ 230-320 mA, alimente-la à part (voir la leçon).
// Sur la caméra : General Settings > Protocol Type > I2C, passe en reconnaissance de couleur, apprends-lui une couleur.
// Ouvre le moniteur série à 115200 baud.
// Le code du HuskyLens est dans le dossier src/ du programme (copie corrigée de la bibliothèque de DFRobot) : aucun ZIP à installer.

#include <Wire.h>
#include "src/HUSKYLENS/HUSKYLENS.h"

const int SDA_PIN = 21;   // la broche de données I2C habituelle de l'ESP32 DevKitC
const int SCL_PIN = 22;   // la broche d'horloge I2C habituelle de l'ESP32 DevKitC

const int TARGET_ID = 1;       // la première couleur apprise à la caméra
const int CENTER_X = 160;      // l'écran fait 320 de large, donc le milieu est à 160
const int DEAD_BAND = 20;      // plus près que ça du milieu = « centré »
const unsigned long LOOK_INTERVAL = 100;   // on regarde toutes les 100 ms

HUSKYLENS huskylens;
unsigned long lastLook = 0;

void setup() {
  Serial.begin(115200);
  Wire.begin(SDA_PIN, SCL_PIN);   // démarre le bus I2C sur ces deux broches

  while (!huskylens.begin(Wire)) {          // essaie de parler à la caméra
    Serial.println("Camera not found. Check wires and Protocol Type = I2C.");
    delay(1000);                            // rien d'autre à faire pour l'instant : on réessaie
  }
  huskylens.writeAlgorithm(ALGORITHM_COLOR_RECOGNITION);   // mode couleur
  Serial.println("Camera ready.");
}

void loop() {
  unsigned long now = millis();

  if (now - lastLook >= LOOK_INTERVAL) {
    lastLook = now;

    if (!huskylens.requestBlocks(TARGET_ID)) {
      Serial.println("No answer from the camera.");
    } else if (huskylens.available() == 0) {
      Serial.println("Target not seen.");
    } else {
      HUSKYLENSResult block = huskylens.read();   // le premier rectangle trouvé
      int error = block.xCenter - CENTER_X;       // négatif = x plus petit que le milieu
      Serial.print("x=");
      Serial.print(block.xCenter);
      Serial.print(" y=");
      Serial.print(block.yCenter);
      Serial.print(" error=");
      Serial.print(error);
      if (error < -DEAD_BAND) {
        Serial.println("  x smaller than the middle");
      } else if (error > DEAD_BAND) {
        Serial.println("  x bigger than the middle");
      } else {
        Serial.println("  centred");
      }
    }
  }
}

Télécharger le dossier du croquis (.zip)

Moniteur série à 115200 baud. Déplace l’objet dans la vue de la caméra :

x=142 y=118 error=-18  centred
x=250 y=120 error=90  x bigger than the middle
Target not seen.

Comment ça marche : huskylens.begin(Wire) essaie de se connecter et dit si ça a réussi [5]. writeAlgorithm(ALGORITHM_COLOR_RECOGNITION) change de mode [5]. requestBlocks(1) ne demande que les rectangles d’ID 1, available() les compte, et read() en donne un [5].


Fais tes propres modifications

Change une seule chose, puis observe.

  1. Déplace la ligne « près ». Dans le programme de distance, mets NEAR_MM à 100, puis à 400. À quelle distance ta DEL se met-elle à vaciller ?
  2. Élargis la zone morte. Dans le programme de la caméra, passe DEAD_BAND de 20 à 60. Que devient le mot « centred » ?
  3. Oriente un servo. Avec A2, ajoute un servo sur sa propre alimentation et ajuste son angle de error / 20 chaque fois que tu vois la cible. De quel côté tourne-t-il ? S’il poursuit la cible dans le mauvais sens, inverse le signe. Que se passe-t-il si tu divises par 5 ? (Attention : un nombre trop grand le fait dépasser la cible et osciller.)

Quand ça ne marche pas

  • « Sensor not found ». Vérifie 3V3, GND, SDA à la GPIO 21 et SCL à la GPIO 22. Lance le scanner de K5 : tu dois voir 0x29 [2][3]. Retire le capuchon de plastique du capteur [3].
  • Toujours « Out of range ». Quelque chose est trop loin ou trop près du capteur. Essaie ta main à environ 20 cm [1][4].
  • « Camera not found ». Vérifie les fils et l’adaptateur de niveau (LV sur 3V3, HV sur 5V, caméra côté HV), que Protocol Type est sur I2C et a bien été enregistré [9][12], et son alimentation [11]. Le scanner de K5 doit trouver la caméra à 0x32 [13]. begin renvoie faux quand il ne peut pas se connecter [5].
  • « No answer from the camera ». La caméra n’a pas répondu à temps. L’attente a une limite, 100 ms par défaut [5]. Vérifie les fils.
  • « Target not seen ». La caméra n’a pas appris de couleur (voir « Apprends-lui une couleur »), ou la couleur n’est pas dans sa vue. L’ID 0 veut dire « détecté, pas appris », et le programme ne demande que l’ID 1 [5].
  • Deux appareils à 0x29. Deux appareils ne peuvent pas partager une adresse. Regarde K5 et le guide d’Adafruit pour savoir comment en changer une [3].
  • Rien dans le moniteur série. Règle-le sur 115200 baud.

Vérifie-toi

Trois petites questions. Rien n’est enregistré, prends ton temps.

  1. Un capteur de distance à temps de vol calcule la distance en mesurant quoi ?

    • La luminosité de la pièce
    • Le temps qu’une impulsion de lumière met à rebondir et revenir au capteur
    • La chaleur de l’objet
    Voir la réponse

    Le temps qu’une impulsion de lumière met à rebondir et revenir au capteur. Le capteur envoie de la lumière et détecte le temps qu’elle met à revenir : le « temps de vol » [1]. Un trajet plus long veut dire un objet plus éloigné.

  2. Un module caméra signale une cible colorée à x = 250, sur un écran qui va de 0 à 320. Avec le milieu à 160, quelle est l’erreur par rapport au centre (x moins le milieu) ?

    • -90, car le milieu moins x est négatif
    • 250, comme x
    • +90, car 250 moins 160 font 90, un nombre positif
    Voir la réponse

    +90, car 250 moins 160 font 90, un nombre positif. Erreur = x moins le milieu : 250 - 160 = +90. L’écran de la caméra fait 320 pixels de large [8], donc le milieu est à 160. Une erreur positive veut dire que x est plus grand que le milieu (160).

  3. Quelle broche de l’ESP32 doit alimenter la carte du capteur de distance, et pourquoi ?

    • 3V3, car la carte doit recevoir la même alimentation que le niveau logique du microcontrôleur, soit 3,3 V sur l’ESP32
    • 5V, car plus de tension donne une plus grande portée
    • N’importe quelle GPIO, car une carte n’a presque pas besoin de courant
    Voir la réponse

    3V3, car la carte doit recevoir la même alimentation que le niveau logique du microcontrôleur, soit 3,3 V sur l’ESP32. La carte accepte de 3 à 5 V et son régulateur interne la ramène plus bas ; Adafruit conseille de lui donner la même alimentation que le niveau logique du microcontrôleur [2]. Ainsi SDA et SCL restent à 3,3 V (leçon K5).


En bref

  • Un capteur à temps de vol chronomètre la lumière qui rebondit et la transforme en distance [1]. Son faisceau est étroit [1].
  • Alimente la carte VL53L0X en 3V3, SDA sur la GPIO 21 et SCL sur la GPIO 22. Elle répond par défaut à 0x29 [2][3].
  • Les mesures dont le RangeStatus vaut 4 ne sont pas fiables [4].
  • Un module caméra signale un rectangle : xCenter, yCenter, width, height et un ID [5].
  • L’écran fait 320 pixels de large [8], donc error = xCenter - 160 te dit où est la cible par rapport au milieu.
  • Le HuskyLens accepte de 3,3 à 5 V et demande environ 230 à 320 mA [8] : alimente-le à part, pas depuis la broche 3V3, et relie ses SDA et SCL par un adaptateur de niveau. Mets Protocol Type sur I2C [9].

Prochaines étapes : les projets avec servos (A2), ou la mission de la tourelle à cible colorée.


Sources

Voir les 13 sources
  1. Adafruit, « Adafruit VL53L0X Time of Flight Micro-LIDAR Distance Sensor Breakout : Overview » (temps de vol ; source laser invisible ; cône étroit contrairement au sonar ; portée d’environ 50 à 1 200 mm ; précision de 3 à 12 % selon la lumière et la distance) — https://learn.adafruit.com/adafruit-vl53l0x-micro-lidar-distance-sensor-breakout/overview
  2. Adafruit, « Adafruit VL53L0X Time of Flight Micro-LIDAR Distance Sensor Breakout : Pinouts » (Vin accepte de 3 à 5 V grâce à un régulateur sur la carte ; lui donner la même alimentation que le niveau logique du microcontrôleur ; adresse I2C par défaut 0x29) — https://learn.adafruit.com/adafruit-vl53l0x-micro-lidar-distance-sensor-breakout/pinouts
  3. Adafruit, « Adafruit VL53L0X Time of Flight Micro-LIDAR Distance Sensor Breakout : Arduino Code » (installer « Adafruit VL53L0X » depuis Manage Libraries ; exemple sous File > Examples ; moniteur série à 115200 ; « out of range » ; retirer le capuchon de plastique de protection ; adresse par défaut 0x29 et comment la changer) — https://learn.adafruit.com/adafruit-vl53l0x-micro-lidar-distance-sensor-breakout/arduino-code
  4. Adafruit, bibliothèque Adafruit_VL53L0X, exemple « vl53l0x.ino » (rangingTest, RangeMilliMeter, RangeStatus 4 traité comme hors de portée) — https://raw.githubusercontent.com/adafruit/Adafruit_VL53L0X/master/examples/vl53l0x/vl53l0x.ino
  5. HuskyLens, dépôt HUSKYLENSArduino, README « HUSKYLENS Arduino API » (HUSKYLENSResult avec xCenter, yCenter, width, height, ID ; ID 1 = premier élément appris, 0 = détecté mais pas appris ; begin(Wire) ; writeAlgorithm et ALGORITHM_COLOR_RECOGNITION ; requestBlocks(ID), available(), read() ; délai d’attente par défaut 100 ms) — https://raw.githubusercontent.com/HuskyLens/HUSKYLENSArduino/master/README.md
  6. Adafruit, « Distance Measurement with Ultrasound » (la sortie d’écho en 5 V du HC-SR04 ne peut pas être reliée directement à une carte en 3,3 V ; une électronique simple règle le problème) — https://learn.adafruit.com/distance-measurement-ultrasound-hcsr04
  7. Espressif, documentation Arduino-ESP32, « I2C » (sur l’ESP32 générique, les broches I2C par défaut sont la GPIO21 pour SDA et la GPIO22 pour SCL) — https://docs.espressif.com/projects/arduino-esp32/en/latest/api/i2c.html
  8. DFRobot, wiki HuskyLens K210 AI Vision Sensor (SEN0305), page principale (tension d’alimentation de 3,3 à 5,0 V ; courant typique de 320 mA à 3,3 V et de 230 mA à 5,0 V en reconnaissance de visage, lumière d’appoint éteinte ; interfaces UART et I2C ; écran IPS de 2,0 pouces, 320 sur 240 ; broches I2C T = SDA et R = SCL sur le connecteur à 4 broches) — https://wiki.dfrobot.com/HUSKYLENS_V1.0_SKU_SEN0305_SEN0336
  9. DFRobot, wiki HuskyLens, « General Settings » (Protocol Type : UART à trois vitesses, I2C ou détection automatique, valeur par défaut détection automatique) — https://wiki.dfrobot.com/sen0305/docs/22610
  10. DFRobot, wiki HuskyLens, « Function Introduction-Color Recognition » (choisir le mode avec le bouton de fonction ; pointer le « + » sur la couleur ; appui long sur le bouton d’apprentissage puis relâcher ; les ID suivent l’ordre d’apprentissage ; la reconnaissance de couleur dépend beaucoup de la lumière ambiante) — https://wiki.dfrobot.com/sen0305/docs/22645
  11. DFRobot, wiki HuskyLens, « Board Overview » (alimentation par le port USB ou le connecteur à 4 broches, l’USB passe en premier si les deux sont branchés ; s’assurer que la tension et le débit d’alimentation suffisent ; boutons de fonction et d’apprentissage) — https://wiki.dfrobot.com/sen0305/docs/22602
  12. DFRobot, wiki HuskyLens, « Example Code for Arduino-Read Position Data(I2C) » (décompresser la bibliothèque HUSKYLENS dans le dossier libraries d’Arduino, dossier nommé HUSKYLENS ; régler Protocol Type sur I2C ou utiliser la détection automatique ; exemple begin(Wire)) — https://wiki.dfrobot.com/sen0305/docs/22766
  13. HuskyLens, dépôt HUSKYLENSArduino, « HUSKYLENS/HUSKYLENS.h » (la bibliothèque parle à la caméra à l’adresse I2C 0x32) — https://raw.githubusercontent.com/HuskyLens/HUSKYLENSArduino/master/HUSKYLENS/HUSKYLENS.h

Pince ou touche deux fois pour zoomer, glisse pour changer de schéma.Molette avec Ctrl ou double-clic pour zoomer. Les flèches changent de schéma.