APDS9960 Arduino: sensor de gestos, proximidad y color
Guía APDS9960 Arduino: conexión I2C y 3,3 V, gestos arriba, abajo, izquierda y derecha, proximidad y RGB, código SparkFun y Adafruit, pin INT, ESP32 y Pico.
Los proyectos con APDS9960 y Arduino permiten que un solo chip diminuto haga cuatro trabajos: detecta si tu mano se mueve a la derecha, a la izquierda, arriba o abajo, mide lo cerca que está un objeto y lee la luz ambiente y el color separados en canales rojo, verde y azul. Es pariente del sensor del móvil que apaga la pantalla al acercarla a la oreja y ajusta el brillo a la habitación. Es un punto de partida ideal para encender una lámpara, cambiar de canción o moverte por un menú con un gesto, sin tocar nada.
En esta guía verás qué hay dentro del APDS-9960, cómo detecta los gestos, por qué debe funcionar a 3,3 V y cómo conectarlo a un Arduino Uno, un ESP32 y una Raspberry Pi Pico. Con las librerías de SparkFun y Adafruit harás una prueba de gestos, un LED que brilla más al acercar la mano, mediciones de color y lux, control de LED y de música con gestos, y aprenderás a usar el pin INT como interrupción y cuál es el alcance real.

¿Qué es el APDS-9960 y cómo funciona?
El APDS-9960 es un sensor fabricado por Broadcom (antes Avago) que mete un LED infrarrojo (IR) y varios detectores de luz en un encapsulado de unos 4 × 2,4 mm. Para medir la proximidad, el LED IR emite pulsos cortos, la luz reflejada por el objeto vuelve a los fotodiodos y, cuanto más fuerte es el reflejo, más cerca está el objeto. El resultado es un número entre 0 y 255. Para el color no se usa el LED: la luz ambiente cae sobre cuatro fotodiodos con recubrimientos rojo, verde, azul y sin filtro (clear), y cada uno da un número de 16 bits.
La detección de gestos es la parte más ingeniosa. Dentro del chip hay cuatro fotodiodos orientados hacia arriba (U), abajo (D), izquierda (L) y derecha (R). Cuando la mano pasa sobre el sensor, un diodo ve el reflejo primero y el opuesto un poco después. Cuando el valor de proximidad supera un umbral de entrada (40 en la librería de SparkFun), el motor de gestos arranca, escribe las lecturas de los cuatro diodos en un búfer FIFO de 32 entradas y se detiene cuando la mano se aleja. El Arduino lee esas entradas y observa cómo cambia con el tiempo la diferencia entre U y D y entre L y R: si primero U es mayor y después D, la mano se movió hacia abajo.
| Característica | Valor |
|---|---|
| Fabricante | Broadcom (antes Avago) |
| Alimentación del chip (VDD) | 2,4–3,6 V |
| Alimentación del LED IR (VL) | 3,0–4,5 V |
| Interfaz | I2C, hasta 400 kHz |
| Dirección I2C | 0x39 (fija, no se puede cambiar) |
| Proximidad | 8 bits (0–255) |
| Color y luz | 4 canales (clear, rojo, verde, azul), 16 bits por canal |
| Gestos | 4 fotodiodos direccionales (U, D, L, R), FIFO de 32 entradas |
| LED IR | 950 nm, corriente ajustable de 12,5 a 100 mA |
| Alcance práctico de gestos | Unos 10–20 cm |
| Salida de interrupción | INT, drenador abierto, pasa a LOW con un evento |
Pines del módulo y el asunto de los 3,3 V
Lo más habitual es la placa de SparkFun y su clon morado, el GY-9960. Ambos tienen seis pines. La mayoría de los módulos llevan detrás un puente de soldadura llamado PS; mientras está cerrado, la alimentación del LED IR (VL) va conectada directamente a VCC y dejas el pin VL sin conectar.
| Pin | Función | Conexión |
|---|---|---|
| VL | Entrada de alimentación del LED IR | Sin conectar si el puente PS está cerrado |
| GND | Masa | GND |
| VCC | Alimentación del chip | 3,3 V |
| SDA | Línea de datos I2C | Pin SDA de la placa |
| SCL | Línea de reloj I2C | Pin SCL de la placa |
| INT | Salida de interrupción (drenador abierto) | Un pin digital con interrupción |
Conexión: Arduino Uno, ESP32 y Raspberry Pi Pico
| APDS-9960 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 3.3V | 3V3 | 3V3 (OUT) |
| GND | GND | GND | GND |
| SDA | A4 (con conversor de nivel) | GPIO 21 | GP4 |
| SCL | A5 (con conversor de nivel) | GPIO 22 | GP5 |
| INT | D2 | GPIO 4 | GP15 |
| VL | Sin conectar (PS cerrado) | Sin conectar (PS cerrado) | Sin conectar (PS cerrado) |
El ESP32 y la Pico ya trabajan a 3,3 V, así que se conectan directamente. Con el Uno la cosa es algo más enrevesada: la librería Wire del Uno activa resistencias pull-up internas en SDA y SCL y tira de las líneas hacia 5 V, mientras las resistencias del módulo tiran hacia 3,3 V. En la práctica suele funcionar, pero lleva el chip al límite. Lo más sano es poner un conversor de nivel I2C bidireccional entre el Uno y el módulo. Como el pin INT es de drenador abierto, la resistencia pull-up del módulo lo mantiene a 3,3 V; el Uno lee esa tensión como HIGH, por lo que no hace falta activar el pull-up interno para INT. Explicamos cómo funciona el I2C en la guía qué es I2C.
¿SparkFun o Adafruit? Elegir librería
| Característica | SparkFun APDS9960 | Adafruit APDS9960 |
|---|---|---|
| Direcciones de gesto | Arriba, abajo, izquierda, derecha y cerca, lejos | Arriba, abajo, izquierda, derecha |
| Leer proximidad | readProximity(variable) | Valor que devuelve readProximity() |
| Leer color | Funciones sueltas como readRedLight() | Todo de una vez con getColorData(), más lux y temperatura de color |
| Interrupciones | De gesto, proximidad y luz | De proximidad y color, con umbral ajustable |
| ID de chip aceptado | 0xAB y 0x9C | Solo 0xAB |
| Dependencia extra | Ninguna (solo Wire) | Adafruit BusIO |
Las dos librerías están en el Gestor de librerías: busca SparkFun APDS9960 RGB and Gesture Sensor y Adafruit APDS9960 Library. Para gestos, el algoritmo de SparkFun es algo más estable y reconoce también los movimientos de acercar y alejar; para el color, las funciones de lux y temperatura de color de Adafruit facilitan el trabajo. En esta guía usaremos las dos. Si es la primera vez que instalas una librería, echa un vistazo a la guía cómo añadir una librería de Arduino.
Paso a paso: primera prueba de gestos (con el pin INT)
- Conecta el módulo según la tabla anterior: VCC a 3.3V, SDA a A4, SCL a A5 e INT a D2.
- Instala la librería de SparkFun y sube el siguiente sketch al Uno.
- Abre el Monitor Serie a 9600 baudios y espera el mensaje "Jest sensoru hazir" (sensor de gestos listo).
- Pasa la mano a 5–10 cm sobre el sensor de un borde al otro, a una velocidad que tarde más o menos medio segundo.
- Verás YUKARI (arriba), ASAGI (abajo), SOL (izquierda) o SAG (derecha); si las direcciones salen al revés, gira el sensor 90 o 180 grados o intercambia los casos del código.
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}Cuando hay un gesto listo, el APDS-9960 pone el pin INT en LOW y eso dispara la interrupción en el pin D2 del Uno. La función de interrupción solo levanta una bandera; la lectura de verdad se hace en loop(), porque readGesture() lee decenas de bytes por I2C y usar I2C dentro de una interrupción provoca bloqueos. Desactivar la interrupción un momento durante la lectura también evita que el mismo gesto se procese dos veces. Tienes la lógica de las interrupciones en detalle en la guía interrupciones en Arduino.
Detección de proximidad: un LED que brilla al acercar la mano
Medir solo la proximidad, en lugar de gestos, es mucho más sencillo y estable. El sketch siguiente envía el valor de proximidad directamente a un LED con PWM: cuanto más cerca está la mano, más brilla el LED, y se apaga al alejarla. Conecta el LED a D9 con una resistencia de 220 Ω; puedes calcular el valor adecuado con la calculadora de resistencia para 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}El valor de proximidad no son centímetros, sino la intensidad de la luz reflejada. Una hoja blanca puede dar 40 a 15 cm, mientras que una tela negra a la misma distancia se queda por debajo de 10. Por eso conviene usar el APDS-9960 no como medidor de distancia, sino como respuesta a la pregunta "¿se ha acercado algo?". Si necesitas una distancia exacta, el sensor ultrasónico HC-SR04 es una opción más precisa. Si los valores son muy bajos, sube la ganancia a PGAIN_4X o PGAIN_8X; si se quedan siempre en 255, bájala a PGAIN_1X.
Medir el color RGB y la luz ambiente
En la parte de color, el APDS-9960 lee cuatro canales: rojo (R), verde (G), azul (B) y luz total sin filtro (C). La librería de Adafruit calcula además, a partir de esos números en bruto, un valor aproximado de lux y la temperatura de color de la luz en kelvin. El sketch siguiente imprime cada medio segundo los cuatro canales, los lux y los kelvin, y dice qué color domina.
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}Los valores en bruto no son colores absolutos, sino cantidades de luz; la misma tarjeta roja da números muy distintos en una habitación oscura y al sol. Por eso, al comparar colores, fíjate en las proporciones: la relación entre R y C es más estable aunque cambie la luz. Si quieres leer el color de un objeto, acércalo a 1–2 cm del sensor y tapa la luz exterior con la mano o con un tubo. El valor en lux es una aproximación; no sustituye a un luxómetro, pero basta de sobra para saber si la habitación se ha quedado a oscuras. Para proyectos que necesiten distinguir colores con más finura, piensa en sensores pensados solo para el color, como el sensor de color TCS3200 o el TCS34725.
Controlar un LED con gestos (sin el pin INT)
No es obligatorio conectar el pin INT. La librería también puede saber si hay un gesto nuevo consultando por I2C el registro de estado del motor de gestos. Así ahorras un pin y el código queda más simple; a cambio, loop() genera tráfico I2C constante. En el sketch siguiente, un gesto hacia arriba enciende el LED al máximo, uno hacia abajo lo apaga, y los gestos a la derecha y a la izquierda suben y bajan el brillo en pasos de un cuarto.
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}Controlar la música con gestos: con el DFPlayer Mini

El uso más divertido de un sensor de gestos es un reproductor de música sin contacto. Conecta el pin RX del DFPlayer Mini al D11 del Uno a través de una resistencia de 1 kΩ y el pin TX al D10; conecta el altavoz a SPK_1 y SPK_2 y alimenta el módulo con 5V. Copia las canciones en la tarjeta SD con los nombres 0001.mp3, 0002.mp3, etc. Los detalles del módulo están en la guía DFPlayer Mini. Un gesto a la derecha pasa a la canción siguiente y uno a la izquierda a la anterior; los gestos arriba y abajo suben y bajan el volumen, y mantener la mano quieta sobre el sensor pausa y reanuda.
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}Hay un detalle que debes conocer: readGesture() no vuelve hasta que el gesto termina y espera 30 ms entre cada lectura de la FIFO. Mientras tengas la mano sobre el sensor, el Arduino no hace nada más. Para un reproductor de música no es un problema, pero si el mismo sketch tiene un motor o una animación en pantalla que necesitan responder rápido, tendrás que organizarlos alrededor de la lectura de gestos.
El pin INT y el ESP32: detección de proximidad por interrupción
El pin INT no sirve solo para los gestos; también se puede usar con umbrales de proximidad y de luz. Fijas un umbral y, cuando una lectura lo supera, el APDS-9960 pone INT en LOW y lo mantiene así hasta que lo borres. De este modo el microcontrolador no tiene que consultar el sensor todo el rato. El sketch del ESP32 que sigue usa la librería de Adafruit para disparar INT cuando la proximidad pasa de 150 y alterna el LED de la placa cada vez que se acerca una mano, como un interruptor de luz sin contacto.
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}El tercer parámetro de setProximityInterruptThreshold() (4 por defecto) es la persistencia: indica cuántas lecturas seguidas deben superar el umbral para que salte la interrupción y así filtra el ruido momentáneo. Si no llamas a clearInterrupt(), INT se queda en LOW y te perderás el siguiente acercamiento. Este esquema es muy útil en proyectos a batería: pon el ESP32 en deep sleep y despiértalo desde el pin INT con esp_sleep_enable_ext0_wakeup(GPIO_NUM_4, 0); la placa solo se despertará cuando alguien acerque la mano. GPIO 4 es un pin RTC, así que sirve para esto.
APDS-9960 con la Raspberry Pi Pico (MicroPython)
En la Raspberry Pi Pico puedes hacer funcionar el APDS-9960 en MicroPython sin ninguna librería, escribiendo directamente en sus registros. El código siguiente lee el ID del chip, activa la medición de color y de proximidad e imprime cada 200 ms los cuatro canales de color y el valor de proximidad. La conexión usa el bus I2C0: SDA a GP4, SCL a GP5 y VCC al pin 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)Esto es lo que hacen los registros del código: 0x80 (ENABLE) elige qué bloques están activos, 0x81 (ATIME) fija el tiempo de integración del color (2,78 ms por paso), 0x8F (CONTROL) define la corriente del LED IR y las ganancias, 0x93 (STATUS) indica si hay datos listos, 0x94–0x9B guardan los canales de color y 0x9C el valor de proximidad. Para los gestos tendrías que leer la FIFO y escribir un algoritmo de dirección como el de SparkFun, lo que es un trabajo más largo. Si prefieres el Arduino IDE, instala el núcleo arduino-pico en la Pico y usa la librería de SparkFun tal cual; los pines I2C por defecto vuelven a ser GP4 y GP5.
Límite de alcance y uso correcto
El APDS-9960 se diseñó como sensor de móvil y su alcance es corto. En la práctica los gestos son fiables entre 5 y 15 cm y, como mucho, llegan a 20 cm. La proximidad da valores útiles hasta una distancia parecida. Lo que marca este límite es la potencia del LED IR y cuánta luz refleja tu mano; subir la corriente del LED a 100 mA y la ganancia al máximo añade algo de alcance, pero también más ruido.
| Factor | Efecto | Qué hacer |
|---|---|---|
| Distancia | Más allá de 15 cm los gestos desaparecen | Pasa la mano a 5–10 cm |
| Velocidad del movimiento | Las pasadas muy lentas o muy rápidas no se detectan | Un movimiento fluido de medio segundo |
| Luz del sol | El IR del sol satura los fotodiodos | Úsalo a la sombra o en interiores |
| Cristal o tapa transparente | La tapa devuelve el IR y la proximidad siempre sale alta | Quita la tapa o usa un material fino que deje pasar el IR |
| Color de la superficie | Un guante negro refleja menos | Sube la ganancia |
| Orientación del sensor | Las direcciones giran | Intercambia los casos de dirección en el código |
Ideas de proyectos con el APDS-9960
- Lámpara sin contacto: Enciende y apaga un módulo de relé con la interrupción de proximidad; muy práctico en la cocina con las manos sucias.
- Lámpara de colores por gestos: Recorre colores en un LED RGB o en una tira WS2812B con gestos a la derecha y a la izquierda.
- Menú en el aire: Elige opciones en una pantalla OLED con gestos arriba y abajo y confirma con NEAR.
- Tapa con servo por gestos: Abre la tapa de una caja con un gesto y un servomotor.
- Brillo automático de pantalla: Ajusta una pantalla o una tira LED a la luz ambiente; frente a una LDR obtienes una lectura más estable y con información de color.
- Clasificador de colores: Separa caramelos o piezas de colores que bajan por una rampa según sus canales de color.
Errores frecuentes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| "APDS-9960 bulunamadi" (no encontrado) | Error de cableado, sin 3,3 V o ID de chip distinto | Busca 0x39 con un escáner I2C y lee el ID |
| Se detecta el módulo pero init falla | Chip clon con otro ID, como 0xA8 | Añade ese valor a la comprobación de ID de la librería |
| No detecta ningún gesto | Mano muy lejos o muy lenta, VL sin alimentar | Pasa a 5–10 cm en medio segundo, revisa el puente PS |
| Direcciones invertidas o mezcladas | Orientación de montaje del sensor | Intercambia los casos DIR en el código |
| Proximidad siempre alta | Cristal, tapa o una superficie cercana delante | Quita la tapa, baja la ganancia |
| No funciona al aire libre | La luz del sol tapa el IR | Úsalo a la sombra |
| Bloqueos aleatorios en el Uno | Desajuste I2C entre 5 V y 3,3 V, cables largos | Conversor de nivel y cables cortos |
| INT se queda en LOW | No se borró la interrupción | Llama a clearInterrupt() después de leer |
Con un solo módulo pequeño, el APDS-9960 añade a tu proyecto control sin contacto, detección de proximidad y medición de color. Si tienes presentes su corto alcance y la regla de los 3,3 V, se convierte en un elemento de interfaz fiable. En la app BlueGrays encontrarás proyectos de LED RGB, medición de luz con LDR, sensor de movimiento y medición de distancia con su esquema y su código paso a paso, y puedes añadirles el APDS-9960 para crear versiones sin contacto.
Preguntas frecuentes
¿El APDS-9960 funciona con 5 V?
No, el chip APDS-9960 trabaja entre 2,4 y 3,6 V y los 5 V pueden dañarlo. Alimenta el módulo desde el pin de 3.3V del Arduino Uno y, si puedes, pon un conversor de nivel en las líneas SDA y SCL. Solo las versiones especiales que indican claramente que llevan regulador y conversor de nivel admiten 5 V.
¿Cuál es la dirección I2C del APDS-9960?
La dirección I2C del APDS-9960 es 0x39 y no se puede cambiar. Por eso no puedes conectar dos APDS-9960 al mismo bus I2C; si necesitas dos sensores, usa un multiplexor I2C como el TCA9548A o el segundo bus I2C del ESP32 o de la Pico.
¿A qué distancia detecta gestos el APDS-9960?
En la práctica detecta gestos de forma fiable entre 5 y 15 cm y, en buenas condiciones, hasta 20 cm. El alcance depende de cuánta luz refleja tu mano, de la corriente del LED IR y de la ganancia. La luz del sol y un cristal delante del sensor reducen el alcance de forma notable.
¿Es obligatorio conectar el pin INT del APDS-9960?
No. Las librerías también pueden leer gestos y proximidad consultando por I2C; en SparkFun lo hace enableGestureSensor(false). El pin INT avisa del evento al instante sin consultas continuas, lo que descarga al procesador y permite despertar a un ESP32 del sueño profundo.
¿Qué precisión tiene el APDS-9960 midiendo colores?
El APDS-9960 mide sus canales de color con 16 bits de resolución, pero da valores en bruto que dependen de la luz ambiente y no colores absolutos. Si acercas el objeto y tapas la luz exterior, distingue sin problemas tarjetas rojas, verdes y azules. Para distinguir colores con más precisión son mejores los sensores dedicados al color como el TCS34725 o el TCS3200.
¿Por qué el APDS-9960 da el error init failed?
Este error indica que la librería no pudo leer el ID del sensor o no encontró el valor esperado. Revisa el cableado, la alimentación de 3,3 V y que SDA y SCL no estén cruzados, y después busca la dirección 0x39 con un escáner I2C. Si la dirección aparece, el chip puede ser un clon; lee el valor del registro de ID y añádelo a la lista que acepta la librería.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Medir la intensidad de luz con LDR
¿Quieres ver en números cuánta luz hay en tu habitación? El LDR, una pequeña pieza sensible a la luz, mide la luz ambiente y el Arduino escribe el valor en la pantalla del ordenador cada medio…

Uso de Led RGB
Dentro de un solo LED se esconden tres colores: el LED RGB se enciende en rojo, luego en verde y luego en azul, cada color medio segundo encendido y medio segundo apagado, y la secuencia vuelve a…

Transición de color suave con Led RGB
Un solo LED RGB pasa lentamente del rojo al verde, del verde al azul y vuelve al rojo, en un bucle de arcoíris que nunca se detiene.

Detector de movimiento con sensor de movimiento
Un vigilante sencillo que te avisa cuando alguien entra en la habitación. El sensor de movimiento capta el calor que desprende el cuerpo humano, y el Arduino mantiene el LED encendido mientras hay…

Timbre y luz con sensor de movimiento
Cuando alguien se acerca a tu puerta, te enteras antes de que llame. En cuanto el sensor de movimiento detecta a alguien, se enciende el LED y el zumbador toca un timbre de tres notas de agudo a…

Lectura de reflexión (proximidad) con TCRT5000
Con un pequeño sensor que emite luz invisible y mide cuánta rebota, detectas la superficie que tiene delante.

Control de LED RGB con ESP32
Generación ilimitada de colores con un solo LED RGB en lugar de 3 LEDs separados. Hacemos transición arco iris estableciendo valores R/G/B con analogWrite() como en Arduino. La teoría del color (como rojo+verde=amarillo) se ve de forma práctica.

Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)
Con un ESP32, un sensor de movimiento PIR, un sensor de luz LDR y un módulo de relé convertimos el pasillo, el baño o la despensa de tu casa en iluminación inteligente. Si ya hay luz, la lámpara no se enciende aunque haya movimiento, así no gasta energía de día. La luz se queda encendida 30 segundos y el tiempo se alarga solo mientras siga habiendo movimiento.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

