Composants · 13 min de lecture

APDS9960 Arduino : capteur de gestes, proximité et couleur

Guide APDS9960 Arduino : câblage I2C et 3,3 V, gestes haut, bas, gauche et droite, proximité et RGB, code SparkFun et Adafruit, broche INT, ESP32 et Pico.

Les projets APDS9960 Arduino confient quatre tâches à une seule puce minuscule : elle détecte si ta main se déplace vers la droite, la gauche, le haut ou le bas, mesure la proximité d'un objet et lit la lumière ambiante et la couleur séparées en canaux rouge, vert et bleu. C'est un cousin du capteur de smartphone qui éteint l'écran quand tu le portes à l'oreille et règle la luminosité selon la pièce. C'est un point de départ idéal pour allumer une lampe, changer de morceau ou parcourir un menu d'un geste, sans rien toucher.

Dans ce guide, tu verras ce que contient l'APDS-9960, comment il détecte les gestes, pourquoi il doit fonctionner en 3,3 V et comment le brancher à un Arduino Uno, un ESP32 et un Raspberry Pi Pico. Avec les bibliothèques SparkFun et Adafruit, tu réaliseras un test de gestes, une LED qui s'illumine quand la main approche, des mesures de couleur et de lux, une commande de LED et de musique par gestes, et tu apprendras à utiliser la broche INT comme interruption et à connaître la vraie portée du capteur.

Module capteur de couleur, de proximité et de gestes APDS-9960
Module APDS-9960 : gestes, proximité, couleur RGB et lumière ambiante dans une seule puce ; il se branche en I2C et demande 3,3 V.

Qu'est-ce que l'APDS-9960 et comment fonctionne-t-il ?

L'APDS-9960 est un capteur fabriqué par Broadcom (anciennement Avago) qui réunit une LED infrarouge (IR) et plusieurs détecteurs de lumière dans un boîtier d'environ 4 × 2,4 mm. Pour la proximité, la LED IR émet de brèves impulsions, la lumière renvoyée par l'objet revient sur les photodiodes et, plus le reflet est fort, plus l'objet est proche. Le résultat est un nombre entre 0 et 255. La mesure de couleur n'utilise pas la LED : la lumière ambiante tombe sur quatre photodiodes munies de filtres rouge, vert, bleu et sans filtre (clear), et chacune fournit un nombre sur 16 bits.

La détection de gestes est la partie la plus astucieuse. La puce contient quatre photodiodes orientées vers le haut (U), le bas (D), la gauche (L) et la droite (R). Quand ta main passe au-dessus du capteur, une diode voit le reflet en premier et la diode opposée un peu plus tard. Lorsque la valeur de proximité dépasse un seuil d'entrée (40 dans la bibliothèque SparkFun), le moteur de gestes démarre, écrit les mesures des quatre diodes dans une mémoire FIFO de 32 entrées et s'arrête quand la main s'éloigne. L'Arduino lit ces entrées et observe comment évoluent les écarts entre U et D et entre L et R : si U est plus grand d'abord et D ensuite, la main est descendue.

CaractéristiqueValeur
FabricantBroadcom (anciennement Avago)
Alimentation de la puce (VDD)2,4–3,6 V
Alimentation de la LED IR (VL)3,0–4,5 V
InterfaceI2C, jusqu'à 400 kHz
Adresse I2C0x39 (fixe, non modifiable)
Proximité8 bits (0–255)
Couleur et lumière4 canaux (clear, rouge, vert, bleu), 16 bits par canal
Gestes4 photodiodes directionnelles (U, D, L, R), FIFO de 32 entrées
LED IR950 nm, courant réglable de 12,5 à 100 mA
Portée pratique des gestesEnviron 10–20 cm
Sortie d'interruptionINT, drain ouvert, passe à LOW lors d'un événement

Broches du module et la question des 3,3 V

On trouve surtout la carte SparkFun et sa copie violette, le GY-9960. Les deux ont six broches. La plupart des modules ont au dos un pont de soudure nommé PS ; tant qu'il est fermé, l'alimentation de la LED IR (VL) est reliée directement à VCC et tu laisses la broche VL non connectée.

BrocheRôleBranchement
VLEntrée d'alimentation de la LED IRNon connectée si le pont PS est fermé
GNDMasseGND
VCCAlimentation de la puce3,3 V
SDALigne de données I2CBroche SDA de la carte
SCLLigne d'horloge I2CBroche SCL de la carte
INTSortie d'interruption (drain ouvert)Une broche numérique avec interruption
La puce APDS-9960 accepte au maximum 3,6 V ; brancher VCC sur la broche 5V de l'Arduino peut la détruire définitivement. Sauf versions spéciales avec régulateur et convertisseur de niveau intégrés, alimente toujours le module en 3,3 V. Certains modules bon marché ne précisent rien ; dans le doute, utilise 3,3 V.

Câblage : Arduino Uno, ESP32 et Raspberry Pi Pico

APDS-9960Arduino UnoESP32Raspberry Pi Pico
VCC3.3V3V33V3 (OUT)
GNDGNDGNDGND
SDAA4 (via un convertisseur de niveau)GPIO 21GP4
SCLA5 (via un convertisseur de niveau)GPIO 22GP5
INTD2GPIO 4GP15
VLNon connectée (PS fermé)Non connectée (PS fermé)Non connectée (PS fermé)

L'ESP32 et le Pico fonctionnent déjà en 3,3 V et se branchent directement. Avec l'Uno, c'est un peu plus délicat : la bibliothèque Wire de l'Uno active des résistances de rappel internes sur SDA et SCL et tire les lignes vers 5 V, alors que les résistances du module les tirent vers 3,3 V. En pratique, cela fonctionne souvent, mais la puce travaille à la limite. Le plus sain est d'intercaler un convertisseur de niveau I2C bidirectionnel entre l'Uno et le module. Comme la broche INT est à drain ouvert, la résistance de rappel du module la maintient à 3,3 V ; l'Uno lit cette tension comme HIGH, il est donc inutile d'activer le pull-up interne pour INT. Nous expliquons le fonctionnement de l'I2C dans le guide qu'est-ce que l'I2C.

SparkFun ou Adafruit ? Choisir la bibliothèque

CaractéristiqueSparkFun APDS9960Adafruit APDS9960
Directions de gestesHaut, bas, gauche, droite plus proche et loinHaut, bas, gauche, droite
Lecture de la proximitéreadProximity(variable)Valeur renvoyée par readProximity()
Lecture de la couleurFonctions séparées comme readRedLight()Tout d'un coup avec getColorData(), plus lux et température de couleur
InterruptionsGestes, proximité et lumièreProximité et couleur, avec seuil réglable
Identifiant de puce accepté0xAB et 0x9C0xAB seulement
Dépendance supplémentaireAucune (Wire seulement)Adafruit BusIO

Les deux bibliothèques sont dans le gestionnaire de bibliothèques : cherche SparkFun APDS9960 RGB and Gesture Sensor et Adafruit APDS9960 Library. Pour les gestes, l'algorithme de SparkFun est un peu plus stable et reconnaît aussi les mouvements d'approche et d'éloignement ; pour la couleur, les fonctions de lux et de température de couleur d'Adafruit simplifient le travail. Nous utiliserons les deux dans ce guide. Si c'est ta première installation de bibliothèque, jette un œil au guide ajouter une bibliothèque Arduino.

Pas à pas : premier test de gestes (avec la broche INT)

  1. Branche le module selon le tableau ci-dessus : VCC sur 3.3V, SDA sur A4, SCL sur A5, INT sur D2.
  2. Installe la bibliothèque SparkFun et téléverse le sketch ci-dessous sur l'Uno.
  3. Ouvre le moniteur série à 9600 bauds et attends le message "Jest sensoru hazir" (capteur de gestes prêt).
  4. Passe la main à 5–10 cm au-dessus du capteur, d'un bord à l'autre, à une vitesse qui prend environ une demi-seconde.
  5. Tu verras YUKARI (haut), ASAGI (bas), SOL (gauche) ou SAG (droite) ; si les directions sont inversées, tourne le capteur de 90 ou 180 degrés ou échange les cas dans le code.
C++ (Arduino IDE)
1#include <Wire.h>
2#include <SparkFun_APDS9960.h>
3
4const int APDS_INT = 2;                 // kesme pini (Uno'da 2 ya da 3) / interrupt pin (2 or 3 on Uno)
5SparkFun_APDS9960 apds;
6volatile bool gestureFlag = false;
7
8void onGesture() {                      // INT LOW'a düşünce çalışır / runs when INT goes LOW
9  gestureFlag = true;
10}
11
12void handleGesture() {
13  if (!apds.isGestureAvailable()) return;
14  switch (apds.readGesture()) {
15    case DIR_UP:    Serial.println("YUKARI / UP");    break;
16    case DIR_DOWN:  Serial.println("ASAGI / DOWN");   break;
17    case DIR_LEFT:  Serial.println("SOL / LEFT");     break;
18    case DIR_RIGHT: Serial.println("SAG / RIGHT");    break;
19    case DIR_NEAR:  Serial.println("YAKIN / NEAR");   break;
20    case DIR_FAR:   Serial.println("UZAK / FAR");     break;
21    default:        Serial.println("BELIRSIZ / NONE");
22  }
23}
24
25void setup() {
26  Serial.begin(9600);
27  pinMode(APDS_INT, INPUT);             // modüldeki pull-up 3,3 V'a çeker / module pull-up to 3.3 V
28  attachInterrupt(digitalPinToInterrupt(APDS_INT), onGesture, FALLING);
29
30  if (!apds.init()) {                   // Wire.begin() kütüphanenin içinde / Wire.begin() is inside
31    Serial.println("APDS-9960 bulunamadi / not found");
32    while (true);
33  }
34  if (apds.enableGestureSensor(true)) { // true = jest olunca INT LOW / true = INT goes LOW on a gesture
35    Serial.println("Jest sensoru hazir / gesture sensor ready");
36  }
37}
38
39void loop() {
40  if (gestureFlag) {
41    detachInterrupt(digitalPinToInterrupt(APDS_INT));   // okurken yeni kesme gelmesin / no new IRQ while reading
42    handleGesture();
43    gestureFlag = false;
44    attachInterrupt(digitalPinToInterrupt(APDS_INT), onGesture, FALLING);
45  }
46}

Quand un geste est prêt, l'APDS-9960 met la broche INT à LOW, ce qui déclenche l'interruption sur la broche D2 de l'Uno. La fonction d'interruption ne fait que lever un drapeau ; la lecture proprement dite a lieu dans loop(), car readGesture() lit des dizaines d'octets en I2C et utiliser l'I2C dans une interruption provoque des blocages. Désactiver brièvement l'interruption pendant la lecture évite aussi de traiter deux fois le même geste. Tu trouveras la logique des interruptions en détail dans le guide interruptions Arduino.

Pour de meilleurs résultats, garde la main à plat et ouverte et passe-la à 5–10 cm du capteur en une demi-seconde. Trop lent, et le moteur de gestes s'arrête avant la fin du mouvement ; trop rapide, et la FIFO ne reçoit pas assez de données. Si tu descends la main juste au-dessus du capteur et la gardes immobile un instant, c'est détecté comme NEAR ; si tu la gardes puis la relèves lentement, comme FAR. Ces deux mouvements sont moins fiables que les quatre directions.

Détection de proximité : une LED qui s'allume quand la main approche

Mesurer seulement la proximité, plutôt que les gestes, est bien plus simple et stable. Le sketch ci-dessous envoie directement la valeur de proximité à une LED en PWM : plus ta main est proche, plus la LED brille, et elle s'éteint quand tu t'éloignes. Branche la LED sur D9 avec une résistance de 220 Ω ; tu peux trouver la bonne valeur avec le calculateur de résistance pour LED.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <SparkFun_APDS9960.h>
3
4SparkFun_APDS9960 apds;
5const int LED_PIN = 9;                  // PWM pini / PWM pin
6
7void setup() {
8  Serial.begin(9600);
9  pinMode(LED_PIN, OUTPUT);
10  if (!apds.init()) {
11    Serial.println("APDS-9960 bulunamadi / not found");
12    while (true);
13  }
14  apds.setProximityGain(PGAIN_2X);      // kazanç: 1X, 2X, 4X, 8X / gain
15  apds.enableProximitySensor(false);    // false = kesme yok / no interrupt
16}
17
18void loop() {
19  uint8_t prox = 0;                     // 0 = uzak, 255 = çok yakın / 0 far, 255 very close
20  if (apds.readProximity(prox)) {
21    analogWrite(LED_PIN, prox);         // el yaklaştıkça LED parlar / LED gets brighter as the hand comes closer
22    Serial.println(prox);
23  }
24  delay(50);
25}

La valeur de proximité n'est pas une distance en centimètres, mais l'intensité de la lumière réfléchie. Une feuille blanche peut donner 40 à 15 cm, alors qu'un tissu noir à la même distance reste sous 10. Utilise donc l'APDS-9960 non pas comme télémètre, mais comme réponse à la question "quelque chose s'est-il approché ?". Si tu as besoin d'une distance précise, le capteur à ultrasons HC-SR04 est un choix plus juste. Si les valeurs sont très faibles, passe le gain à PGAIN_4X ou PGAIN_8X ; si elles restent bloquées à 255, descends à PGAIN_1X.

Mesurer la couleur RGB et la lumière ambiante

Côté couleur, l'APDS-9960 lit quatre canaux : rouge (R), vert (G), bleu (B) et lumière totale non filtrée (C). À partir de ces valeurs brutes, la bibliothèque Adafruit calcule aussi une valeur approximative en lux et la température de couleur de la lumière en kelvins. Le sketch ci-dessous affiche toutes les demi-secondes les quatre canaux, les lux et les kelvins, et indique la couleur dominante.

C++ (Arduino IDE)
1#include <Adafruit_APDS9960.h>
2
3Adafruit_APDS9960 apds;
4
5void setup() {
6  Serial.begin(9600);
7  if (!apds.begin()) {                  // kimlik 0xAB değilse false / false if the ID is not 0xAB
8    Serial.println("APDS-9960 bulunamadi / not found");
9    while (true);
10  }
11  apds.setADCIntegrationTime(100);      // 100 ms ölçüm: daha hassas / 100 ms integration: more sensitive
12  apds.enableColor(true);               // renk + ortam ışığı / colour + ambient light
13}
14
15void loop() {
16  uint16_t r, g, b, c;
17  while (!apds.colorDataReady()) delay(5);              // ölçüm bitene kadar bekle / wait for a reading
18  apds.getColorData(&r, &g, &b, &c);
19  uint16_t lux = apds.calculateLux(r, g, b);            // yaklaşık lüks / approximate lux
20  uint16_t cct = apds.calculateColorTemperature(r, g, b); // renk sıcaklığı (K) / colour temperature (K)
21
22  Serial.print("R:");  Serial.print(r);
23  Serial.print(" G:"); Serial.print(g);
24  Serial.print(" B:"); Serial.print(b);
25  Serial.print(" C:"); Serial.print(c);
26  Serial.print("  lux:"); Serial.print(lux);
27  Serial.print("  K:");   Serial.println(cct);
28
29  if (c > 100) {                        // yeterli ışık varsa baskın rengi söyle / name the dominant colour
30    if (r > g && r > b)      Serial.println("Kirmizi / red");
31    else if (g > r && g > b) Serial.println("Yesil / green");
32    else                     Serial.println("Mavi / blue");
33  }
34  delay(500);
35}

Les valeurs brutes ne sont pas des couleurs absolues mais des quantités de lumière ; la même carte rouge donne des nombres très différents dans une pièce sombre et en plein soleil. Pour comparer des couleurs, regarde donc les rapports : le rapport entre R et C reste plus stable même quand la lumière change. Pour lire la couleur d'un objet, approche-le à 1–2 cm du capteur et masque la lumière extérieure avec la main ou un tube. La valeur en lux est une approximation ; elle ne remplace pas un luxmètre, mais suffit largement pour savoir si la pièce s'est assombrie. Pour des projets qui demandent une distinction plus fine des couleurs, pense aux capteurs dédiés à la couleur comme le capteur de couleur TCS3200 ou le TCS34725.

Commander une LED par gestes (sans la broche INT)

Tu n'es pas obligé de brancher la broche INT. La bibliothèque peut aussi savoir s'il y a un nouveau geste en interrogeant en I2C le registre d'état du moteur de gestes. Cela économise une broche et simplifie le code ; en contrepartie, loop() génère un trafic I2C permanent. Dans le sketch ci-dessous, un geste vers le haut allume la LED à fond, un geste vers le bas l'éteint, et les gestes à droite et à gauche augmentent et diminuent la luminosité par quarts.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <SparkFun_APDS9960.h>
3
4SparkFun_APDS9960 apds;
5const int LED_PIN = 9;                  // PWM pini / PWM pin
6int level = 0;                          // parlaklık 0-255 / brightness 0-255
7
8void setup() {
9  Serial.begin(9600);
10  pinMode(LED_PIN, OUTPUT);
11  if (!apds.init()) {
12    Serial.println("APDS-9960 bulunamadi / not found");
13    while (true);
14  }
15  apds.enableGestureSensor(false);      // INT olmadan, sorgulayarak / polling, no INT pin
16}
17
18void loop() {
19  if (apds.isGestureAvailable()) {
20    switch (apds.readGesture()) {
21      case DIR_UP:    level = 255; break;                   // tam aç / fully on
22      case DIR_DOWN:  level = 0;   break;                   // kapat / off
23      case DIR_RIGHT: level = min(level + 64, 255); break;  // daha parlak / brighter
24      case DIR_LEFT:  level = max(level - 64, 0);   break;  // daha sönük / dimmer
25      default: break;
26    }
27    analogWrite(LED_PIN, level);
28    Serial.print("Parlaklik / brightness: ");
29    Serial.println(level);
30  }
31}

Commander la musique par gestes : avec le DFPlayer Mini

Module lecteur MP3 DFPlayer Mini
DFPlayer Mini : il lit les fichiers MP3 d'une carte SD et reçoit ses commandes par une liaison série.

L'usage le plus amusant d'un capteur de gestes est un lecteur de musique sans contact. Relie la broche RX du DFPlayer Mini à la broche D11 de l'Uno à travers une résistance de 1 kΩ et la broche TX à D10 ; branche le haut-parleur sur SPK_1 et SPK_2 et alimente le module en 5V. Copie les morceaux sur la carte SD sous les noms 0001.mp3, 0002.mp3, etc. Les détails du module sont dans le guide DFPlayer Mini. Un geste à droite passe au morceau suivant et un geste à gauche au précédent ; les gestes vers le haut et le bas montent et baissent le volume, et garder la main immobile au-dessus du capteur met en pause puis relance la lecture.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <SoftwareSerial.h>
3#include <SparkFun_APDS9960.h>
4#include <DFRobotDFPlayerMini.h>
5
6SoftwareSerial mp3Serial(10, 11);       // RX, TX (TX hattına 1 kΩ / 1 kΩ on the TX line)
7DFRobotDFPlayerMini player;
8SparkFun_APDS9960 apds;
9bool playing = true;
10int volume = 18;                        // ses 0-30 / volume 0-30
11
12void setup() {
13  Serial.begin(9600);
14  mp3Serial.begin(9600);
15  if (!player.begin(mp3Serial)) { Serial.println("DFPlayer yok / not found"); while (true); }
16  if (!apds.init())             { Serial.println("APDS-9960 yok / not found"); while (true); }
17  apds.enableGestureSensor(false);
18  player.volume(volume);
19  player.play(1);                       // SD karttaki 0001.mp3 / 0001.mp3 on the SD card
20}
21
22void loop() {
23  if (!apds.isGestureAvailable()) return;
24  switch (apds.readGesture()) {
25    case DIR_RIGHT: player.next();     Serial.println("Sonraki / next");       break;
26    case DIR_LEFT:  player.previous(); Serial.println("Onceki / previous");    break;
27    case DIR_UP:    volume = min(volume + 3, 30); player.volume(volume);      break;
28    case DIR_DOWN:  volume = max(volume - 3, 0);  player.volume(volume);      break;
29    case DIR_NEAR:                      // eli sensör üzerinde sabit tut / hold the hand still
30      if (playing) player.pause(); else player.start();
31      playing = !playing;
32      break;
33    default: break;
34  }
35}

Il y a un détail à connaître : readGesture() ne rend la main qu'une fois le geste terminé et attend 30 ms entre chaque lecture de la FIFO. Tant que ta main reste au-dessus du capteur, l'Arduino ne fait rien d'autre. Pour un lecteur de musique, ce n'est pas un problème, mais si le même sketch pilote un moteur ou une animation à l'écran qui doivent réagir vite, il faudra les organiser autour de la lecture des gestes.

La broche INT et l'ESP32 : détecter la proximité par interruption

La broche INT ne sert pas qu'aux gestes : elle fonctionne aussi avec des seuils de proximité et de lumière. Tu fixes un seuil ; quand une mesure le dépasse, l'APDS-9960 met INT à LOW et l'y maintient jusqu'à ce que tu l'effaces. Le microcontrôleur n'a ainsi plus besoin d'interroger le capteur en permanence. Le sketch ESP32 ci-dessous utilise la bibliothèque Adafruit pour déclencher INT quand la proximité dépasse 150 et bascule la LED de la carte à chaque approche de la main, comme un interrupteur sans contact.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_APDS9960.h>
3
4const int INT_PIN = 4;                  // APDS INT -> GPIO 4
5const int LED_PIN = 2;                  // karttaki LED / on-board LED
6Adafruit_APDS9960 apds;
7bool ledOn = false;
8
9void setup() {
10  Serial.begin(115200);
11  pinMode(INT_PIN, INPUT_PULLUP);       // 3,3 V'a çekmek güvenli / pulling up to 3.3 V is safe
12  pinMode(LED_PIN, OUTPUT);
13  Wire.begin(21, 22);                   // SDA, SCL
14  if (!apds.begin()) {
15    Serial.println("APDS-9960 bulunamadi / not found");
16    while (true) delay(10);
17  }
18  apds.enableProximity(true);
19  apds.setProximityInterruptThreshold(0, 150);  // 150'yi aşınca INT LOW / INT goes LOW above 150
20  apds.enableProximityInterrupt();
21}
22
23void loop() {
24  if (digitalRead(INT_PIN) == LOW) {    // el yaklaştı / a hand came close
25    uint8_t p = apds.readProximity();
26    ledOn = !ledOn;                     // her yaklaşmada aç-kapa / toggle on every approach
27    digitalWrite(LED_PIN, ledOn);
28    Serial.printf("Yakinlik / proximity: %u  LED: %s\n", p, ledOn ? "ON" : "OFF");
29    while (apds.readProximity() > 100) delay(20);  // el çekilene kadar bekle / wait for the hand to leave
30    apds.clearInterrupt();              // INT'i serbest bırak / release INT
31  }
32}

Le troisième paramètre de setProximityInterruptThreshold() (4 par défaut) est la persistance : il indique combien de mesures consécutives doivent dépasser le seuil avant que l'interruption se déclenche, ce qui filtre les parasites passagers. Si tu n'appelles pas clearInterrupt(), INT reste à LOW et tu rates l'approche suivante. Ce montage est très utile pour les projets sur batterie : mets l'ESP32 en deep sleep et réveille-le par la broche INT avec esp_sleep_enable_ext0_wakeup(GPIO_NUM_4, 0) ; la carte ne se réveille que lorsque quelqu'un approche la main. GPIO 4 est une broche RTC, elle convient donc à cet usage.

L'APDS-9960 avec le Raspberry Pi Pico (MicroPython)

Sur le Raspberry Pi Pico, tu peux faire fonctionner l'APDS-9960 en MicroPython sans aucune bibliothèque, en écrivant directement dans ses registres. Le code ci-dessous lit l'identifiant de la puce, active la mesure de couleur et de proximité, puis affiche toutes les 200 ms les quatre canaux de couleur et la valeur de proximité. Le câblage utilise le bus I2C0 : SDA sur GP4, SCL sur GP5 et VCC sur la broche 3V3(OUT).

MicroPython
1from machine import Pin, I2C
2import time
3
4ADDR = 0x39                              # APDS-9960 sabit adresi / fixed address
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
6
7def write(reg, val):
8    i2c.writeto_mem(ADDR, reg, bytes([val]))
9
10def read(reg, n=1):
11    return i2c.readfrom_mem(ADDR, reg, n)
12
13print("ID:", hex(read(0x92)[0]))         # orijinalde 0xAB / 0xAB on a genuine chip
14
15write(0x80, 0x00)                        # ENABLE: her şeyi kapat / everything off
16write(0x81, 0xDB)                        # ATIME: 37 döngü, ~103 ms / 37 cycles, ~103 ms
17write(0x8E, 0x87)                        # PPULSE: 16 us, 8 darbe / 16 us, 8 pulses
18write(0x8F, 0x09)                        # CONTROL: LED 100 mA, PGAIN 4x, AGAIN 4x
19write(0x80, 0x07)                        # ENABLE: PON + AEN (renk/colour) + PEN (yakınlık/proximity)
20time.sleep_ms(150)
21
22while True:
23    if read(0x93)[0] & 0x01:             # STATUS.AVALID: renk verisi hazır / colour data ready
24        d = read(0x94, 8)                # C, R, G, B: ikişer bayt / two bytes each
25        c = d[0] | d[1] << 8
26        r = d[2] | d[3] << 8
27        g = d[4] | d[5] << 8
28        b = d[6] | d[7] << 8
29        prox = read(0x9C)[0]             # PDATA: 0-255
30        print("C", c, "R", r, "G", g, "B", b, "yakinlik/prox", prox)
31    time.sleep_ms(200)

Voici le rôle des registres du code : 0x80 (ENABLE) choisit les blocs actifs, 0x81 (ATIME) fixe le temps d'intégration de la couleur (2,78 ms par pas), 0x8F (CONTROL) règle le courant de la LED IR et les gains, 0x93 (STATUS) indique si des données sont prêtes, 0x94–0x9B contiennent les canaux de couleur et 0x9C la valeur de proximité. Pour les gestes, il faudrait lire la FIFO et écrire un algorithme de direction comme celui de SparkFun, ce qui demande plus de travail. Si tu préfères l'Arduino IDE, installe le cœur arduino-pico sur le Pico et utilise la bibliothèque SparkFun telle quelle ; les broches I2C par défaut sont là aussi GP4 et GP5.

Limite de portée et bon usage

L'APDS-9960 a été conçu comme capteur de téléphone et sa portée est courte. En pratique, les gestes sont fiables entre 5 et 15 cm et atteignent 20 cm au mieux. La proximité donne des valeurs exploitables jusqu'à une distance semblable. Ce qui fixe cette limite, c'est la puissance de la LED IR et la quantité de lumière que renvoie ta main ; pousser le courant de la LED à 100 mA et le gain au maximum ajoute un peu de portée, mais aussi du bruit.

FacteurEffetQue faire ?
DistanceAu-delà de 15 cm, les gestes disparaissentPasse la main à 5–10 cm
Vitesse du mouvementLes passages très lents ou très rapides ne sont pas détectésUn mouvement fluide d'une demi-seconde
SoleilL'IR du soleil sature les photodiodesUtilise-le à l'ombre ou en intérieur
Vitre ou capot transparentLe capot renvoie l'IR, la proximité reste toujours élevéeRetire le capot ou utilise un matériau fin qui laisse passer l'IR
Couleur de la surfaceUn gant noir réfléchit moinsAugmente le gain
Orientation du capteurLes directions tournentÉchange les cas de direction dans le code

Idées de projets avec l'APDS-9960

  • Lampe sans contact : Commande un module relais avec l'interruption de proximité ; très pratique en cuisine quand on a les mains sales.
  • Lampe de couleur par gestes : Fais défiler les couleurs d'une LED RGB ou d'un ruban WS2812B avec des gestes à droite et à gauche.
  • Menu dans les airs : Choisis les entrées d'un menu sur un écran OLED avec des gestes vers le haut et le bas, et valide avec NEAR.
  • Couvercle à servo par gestes : Ouvre le couvercle d'une boîte d'un geste grâce à un servomoteur.
  • Luminosité d'écran automatique : Adapte un écran ou un ruban LED à la lumière ambiante ; par rapport à une LDR, tu obtiens une mesure plus stable avec l'information de couleur.
  • Trieur de couleurs : Trie des bonbons ou des briques colorés qui descendent une goulotte selon leurs canaux de couleur.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
"APDS-9960 bulunamadi" (introuvable)Erreur de câblage, pas de 3,3 V ou identifiant de puce différentCherche 0x39 avec un scanner I2C, lis l'identifiant
Module détecté mais init échouePuce clone avec un autre identifiant comme 0xA8Ajoute cette valeur au contrôle d'identifiant de la bibliothèque
Aucun geste détectéMain trop loin ou trop lente, VL non alimentéePasse à 5–10 cm en une demi-seconde, vérifie le pont PS
Directions inversées ou mélangéesSens de montage du capteurÉchange les cas DIR dans le code
Proximité toujours élevéeVitre, capot ou surface proche devantRetire le capot, baisse le gain
Ne marche pas en extérieurLe soleil noie l'IRUtilise-le à l'ombre
Blocages aléatoires sur l'UnoIncompatibilité I2C entre 5 V et 3,3 V, fils longsConvertisseur de niveau et fils courts
INT reste à LOWInterruption non effacéeAppelle clearInterrupt() après la lecture
En cas de souci, vérifie d'abord avec un sketch scanner I2C que l'adresse 0x39 apparaît, puis lance le code simple qui ne lit que la proximité. Si la valeur passe de 0 à plus de 200 quand tu approches la main, le matériel est bon et le problème vient des réglages de gestes ou du mouvement de ta main.

Avec un seul petit module, l'APDS-9960 apporte à ton projet la commande sans contact, la détection de proximité et la mesure de couleur. Si tu gardes en tête sa courte portée et la règle des 3,3 V, il devient un élément d'interface fiable. Dans l'application BlueGrays, tu trouveras des projets de LED RGB, de mesure de lumière avec une LDR, de détecteur de mouvement et de mesure de distance avec schéma et code pas à pas, auxquels tu peux ajouter l'APDS-9960 pour en faire des versions sans contact.

Questions fréquentes

L'APDS-9960 fonctionne-t-il en 5 V ?

Non, la puce APDS-9960 fonctionne entre 2,4 et 3,6 V et le 5 V peut l'endommager. Alimente le module par la broche 3.3V de l'Arduino Uno et, si possible, place un convertisseur de niveau sur les lignes SDA et SCL. Seules les versions spéciales qui indiquent clairement un régulateur et un convertisseur de niveau intégrés acceptent le 5 V.

Quelle est l'adresse I2C de l'APDS-9960 ?

L'adresse I2C de l'APDS-9960 est 0x39 et elle ne peut pas être modifiée. Tu ne peux donc pas brancher deux APDS-9960 sur le même bus I2C ; si tu as besoin de deux capteurs, utilise un multiplexeur I2C comme le TCA9548A ou le second bus I2C de l'ESP32 ou du Pico.

À quelle distance l'APDS-9960 détecte-t-il les gestes ?

En pratique, les gestes sont détectés de façon fiable entre 5 et 15 cm, et jusqu'à 20 cm dans de bonnes conditions. La portée dépend de la lumière renvoyée par ta main, du courant de la LED IR et du gain. Le soleil et une vitre devant le capteur réduisent nettement la portée.

Faut-il obligatoirement brancher la broche INT de l'APDS-9960 ?

Non. Les bibliothèques peuvent aussi lire les gestes et la proximité en interrogeant le capteur par I2C ; avec SparkFun, c'est le rôle de enableGestureSensor(false). La broche INT signale l'événement immédiatement sans interrogation continue, ce qui soulage le processeur et permet de réveiller un ESP32 de son sommeil profond.

Quelle est la précision de l'APDS-9960 pour les couleurs ?

L'APDS-9960 mesure ses canaux de couleur avec une résolution de 16 bits, mais il fournit des valeurs brutes qui dépendent de la lumière ambiante, pas des couleurs absolues. Si tu approches l'objet et masques la lumière extérieure, il distingue sans peine des cartes rouges, vertes et bleues. Pour une distinction plus fine, mieux vaut un capteur dédié à la couleur comme le TCS34725 ou le TCS3200.

Pourquoi l'APDS-9960 affiche-t-il l'erreur init failed ?

Cette erreur signifie que la bibliothèque n'a pas pu lire l'identifiant du capteur ou n'a pas trouvé la valeur attendue. Vérifie le câblage, l'alimentation en 3,3 V et que SDA et SCL ne sont pas inversées, puis cherche l'adresse 0x39 avec un scanner I2C. Si l'adresse apparaît, la puce est peut-être un clone ; lis la valeur du registre d'identifiant et ajoute-la à la liste acceptée par la bibliothèque.

Voir tous les projets
Mesurer l'intensité lumineuse avec une LDR
AR-11Débutant

Mesurer l'intensité lumineuse avec une LDR

Envie de voir en chiffres à quel point ta chambre est lumineuse ? Le LDR, une petite pièce sensible à la lumière, mesure la lumière ambiante, et l'Arduino écrit la valeur sur l'écran de ton…

4.6(83)
143
Utilisation d'une LED RVB
AR-39Débutant
Premium

Utilisation d'une LED RVB

Trois couleurs se cachent dans une seule LED : la LED RGB s'allume en rouge, puis en vert, puis en bleu, chaque couleur allumée une demi-seconde puis éteinte une demi-seconde, avant que tout…

4.9(73)
100
Transition douce des couleurs avec une LED RVB
AR-40Débutant
Premium

Transition douce des couleurs avec une LED RVB

Une seule LED RGB glisse doucement du rouge au vert, du vert au bleu, puis revient au rouge, dans une boucle arc-en-ciel qui ne s'arrête jamais.

4.8(58)
78
Détecteur de mouvement avec capteur de mouvement
AR-24Débutant
Premium

Détecteur de mouvement avec capteur de mouvement

Un gardien tout simple qui te prévient quand quelqu'un entre dans la pièce. Le détecteur de mouvement repère la chaleur dégagée par le corps humain ; l'Arduino garde la LED allumée tant qu'il y a du…

4.6(47)
67
Sonnette et lumière avec détecteur de mouvement
AR-25Intermédiaire
Premium

Sonnette et lumière avec détecteur de mouvement

Quand quelqu'un approche de ta porte, tu le sais avant même qu'il sonne. Dès que le détecteur de mouvement repère quelqu'un, la LED s'allume et le buzzer joue un carillon de trois notes, de l'aigu au…

4.7(54)
72
Lecture de réflexion (proximité) avec TCRT5000
AR-77Intermédiaire
Premium

Lecture de réflexion (proximité) avec TCRT5000

Avec un petit capteur qui envoie une lumière invisible et mesure ce qui revient, tu détectes la surface placée devant lui.

4.6(33)
43
Contrôle d'une LED RVB avec ESP32
ES-9Débutant

Contrôle d'une LED RVB avec ESP32

Génération illimitée de couleurs avec une seule LED RVB au lieu de 3 LED séparées. Comme dans Arduino, nous réalisons une transition arc-en-ciel en réglant les valeurs R/G/B avec analogWrite(). La théorie des couleurs (telle que rouge+vert=jaune) est mise en pratique.

4.6(29)
52
Éclairage Intelligent ESP32 (PIR + LDR + Relais + OLED)
ES-37Avancé
Premium

Éclairage Intelligent ESP32 (PIR + LDR + Relais + OLED)

Avec un ESP32, un capteur de mouvement PIR, un capteur de lumière LDR et un module relais, on transforme ton couloir, tes toilettes ou ton cellier en éclairage intelligent. Si la pièce est déjà claire, la lumière reste éteinte malgré le mouvement : pas de gaspillage d'énergie en journée. La lumière reste allumée 30 secondes et la durée se prolonge automatiquement tant que le mouvement continue.

4.3(6)
11