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.

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éristique | Valeur |
|---|---|
| Fabricant | Broadcom (anciennement Avago) |
| Alimentation de la puce (VDD) | 2,4–3,6 V |
| Alimentation de la LED IR (VL) | 3,0–4,5 V |
| Interface | I2C, jusqu'à 400 kHz |
| Adresse I2C | 0x39 (fixe, non modifiable) |
| Proximité | 8 bits (0–255) |
| Couleur et lumière | 4 canaux (clear, rouge, vert, bleu), 16 bits par canal |
| Gestes | 4 photodiodes directionnelles (U, D, L, R), FIFO de 32 entrées |
| LED IR | 950 nm, courant réglable de 12,5 à 100 mA |
| Portée pratique des gestes | Environ 10–20 cm |
| Sortie d'interruption | INT, 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.
| Broche | Rôle | Branchement |
|---|---|---|
| VL | Entrée d'alimentation de la LED IR | Non connectée si le pont PS est fermé |
| GND | Masse | GND |
| VCC | Alimentation de la puce | 3,3 V |
| SDA | Ligne de données I2C | Broche SDA de la carte |
| SCL | Ligne d'horloge I2C | Broche SCL de la carte |
| INT | Sortie d'interruption (drain ouvert) | Une broche numérique avec interruption |
Câblage : Arduino Uno, ESP32 et Raspberry Pi Pico
| APDS-9960 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 3.3V | 3V3 | 3V3 (OUT) |
| GND | GND | GND | GND |
| SDA | A4 (via un convertisseur de niveau) | GPIO 21 | GP4 |
| SCL | A5 (via un convertisseur de niveau) | GPIO 22 | GP5 |
| INT | D2 | GPIO 4 | GP15 |
| VL | Non 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éristique | SparkFun APDS9960 | Adafruit APDS9960 |
|---|---|---|
| Directions de gestes | Haut, bas, gauche, droite plus proche et loin | Haut, bas, gauche, droite |
| Lecture de la proximité | readProximity(variable) | Valeur renvoyée par readProximity() |
| Lecture de la couleur | Fonctions séparées comme readRedLight() | Tout d'un coup avec getColorData(), plus lux et température de couleur |
| Interruptions | Gestes, proximité et lumière | Proximité et couleur, avec seuil réglable |
| Identifiant de puce accepté | 0xAB et 0x9C | 0xAB seulement |
| Dépendance supplémentaire | Aucune (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)
- Branche le module selon le tableau ci-dessus : VCC sur 3.3V, SDA sur A4, SCL sur A5, INT sur D2.
- Installe la bibliothèque SparkFun et téléverse le sketch ci-dessous sur l'Uno.
- Ouvre le moniteur série à 9600 bauds et attends le message "Jest sensoru hazir" (capteur de gestes prêt).
- Passe la main à 5–10 cm au-dessus du capteur, d'un bord à l'autre, à une vitesse qui prend environ une demi-seconde.
- 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.
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.
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.
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.
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.
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

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.
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.
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).
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.
| Facteur | Effet | Que faire ? |
|---|---|---|
| Distance | Au-delà de 15 cm, les gestes disparaissent | Passe la main à 5–10 cm |
| Vitesse du mouvement | Les passages très lents ou très rapides ne sont pas détectés | Un mouvement fluide d'une demi-seconde |
| Soleil | L'IR du soleil sature les photodiodes | Utilise-le à l'ombre ou en intérieur |
| Vitre ou capot transparent | Le capot renvoie l'IR, la proximité reste toujours élevée | Retire le capot ou utilise un matériau fin qui laisse passer l'IR |
| Couleur de la surface | Un gant noir réfléchit moins | Augmente le gain |
| Orientation du capteur | Les 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ôme | Cause probable | Solution |
|---|---|---|
| "APDS-9960 bulunamadi" (introuvable) | Erreur de câblage, pas de 3,3 V ou identifiant de puce différent | Cherche 0x39 avec un scanner I2C, lis l'identifiant |
| Module détecté mais init échoue | Puce clone avec un autre identifiant comme 0xA8 | Ajoute cette valeur au contrôle d'identifiant de la bibliothèque |
| Aucun geste détecté | Main trop loin ou trop lente, VL non alimentée | Passe à 5–10 cm en une demi-seconde, vérifie le pont PS |
| Directions inversées ou mélangées | Sens de montage du capteur | Échange les cas DIR dans le code |
| Proximité toujours élevée | Vitre, capot ou surface proche devant | Retire le capot, baisse le gain |
| Ne marche pas en extérieur | Le soleil noie l'IR | Utilise-le à l'ombre |
| Blocages aléatoires sur l'Uno | Incompatibilité I2C entre 5 V et 3,3 V, fils longs | Convertisseur de niveau et fils courts |
| INT reste à LOW | Interruption non effacée | Appelle clearInterrupt() après la lecture |
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.
Projets à réaliser après cet article
Voir tous les projets
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…

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…

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.

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…

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…

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.

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.

É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.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

