Bauteile · 11 Min. Lesezeit

APDS9960 Arduino: Gestensensor, Näherung und Farbe nutzen

APDS9960 Arduino Anleitung: I2C und 3,3 V, Gesten links-rechts-hoch-runter, Näherung und RGB messen, SparkFun- und Adafruit-Code, INT-Pin, ESP32 und Pico.

Mit APDS9960 Arduino-Projekten erledigt ein einziger winziger Chip vier Aufgaben: Er erkennt, ob sich deine Hand nach rechts, links, oben oder unten bewegt, misst, wie nah ein Gegenstand ist, und liest Umgebungslicht und Farbe getrennt nach den Kanälen Rot, Grün und Blau. Er ist ein Verwandter des Handysensors, der den Bildschirm am Ohr abschaltet und die Helligkeit an den Raum anpasst. Für eine Lampe, die du mit einer Handbewegung einschaltest, einen Liedwechsel ohne Berührung oder die Steuerung eines Menüs ist er ein idealer Einstieg.

In dieser Anleitung siehst du, was im APDS-9960 steckt, wie er Gesten erkennt, warum er mit 3,3 V laufen muss und wie du ihn an Arduino Uno, ESP32 und Raspberry Pi Pico anschließt. Mit den Bibliotheken von SparkFun und Adafruit baust du einen Gestentest, eine LED, die heller wird, wenn sich die Hand nähert, misst Farbe und Lux, steuerst LEDs und Musik per Geste und lernst, den INT-Pin als Interrupt zu nutzen und wo die echte Reichweite endet.

APDS-9960 Farb-, Näherungs- und Gestensensormodul
APDS-9960-Modul: Gesten, Näherung, RGB-Farbe und Umgebungslicht in einem Chip; Anschluss per I2C, Versorgung mit 3,3 V.

Was ist der APDS-9960 und wie funktioniert er?

Der APDS-9960 ist ein Sensor von Broadcom (früher Avago), der eine Infrarot-LED (IR) und mehrere Lichtdetektoren in ein Gehäuse von etwa 4 × 2,4 mm packt. Bei der Näherungsmessung sendet die IR-LED kurze Impulse, das vom Gegenstand zurückgeworfene Licht trifft auf die Fotodioden, und je stärker die Reflexion, desto näher ist der Gegenstand. Das Ergebnis ist eine Zahl zwischen 0 und 255. Für die Farbmessung wird die LED nicht gebraucht: Das Umgebungslicht fällt auf vier getrennte Fotodioden mit roter, grüner, blauer und ungefilterter (Clear) Beschichtung, und jede liefert eine 16-Bit-Zahl.

Die Gestenerkennung ist der klügste Teil. Im Chip sitzen vier Fotodioden, die nach oben (U), unten (D), links (L) und rechts (R) ausgerichtet sind. Fährt deine Hand über den Sensor, sieht eine Diode die Reflexion zuerst und die gegenüberliegende etwas später. Überschreitet der Näherungswert eine Einstiegsschwelle (40 in der SparkFun-Bibliothek), startet die Gesten-Engine, schreibt die Messwerte der vier Dioden in einen FIFO-Puffer mit 32 Einträgen und stoppt, wenn sich die Hand entfernt. Der Arduino liest diese Einträge und prüft, wie sich der Unterschied zwischen U und D sowie zwischen L und R mit der Zeit ändert: Ist zuerst U größer und danach D, hat sich die Hand nach unten bewegt.

MerkmalWert
HerstellerBroadcom (früher Avago)
Chipversorgung (VDD)2,4–3,6 V
IR-LED-Versorgung (VL)3,0–4,5 V
SchnittstelleI2C, bis 400 kHz
I2C-Adresse0x39 (fest, nicht änderbar)
Näherung8 Bit (0–255)
Farbe und Licht4 Kanäle (Clear, Rot, Grün, Blau), 16 Bit pro Kanal
Gesten4 Richtungsfotodioden (U, D, L, R), FIFO mit 32 Einträgen
IR-LED950 nm, Strom von 12,5 bis 100 mA einstellbar
Praktische GestenreichweiteEtwa 10–20 cm
Interrupt-AusgangINT, Open-Drain, geht bei einem Ereignis auf LOW

Modulpins und die Sache mit den 3,3 V

Am häufigsten findest du das SparkFun-Board und seinen lila Nachbau, das GY-9960. Beide haben sechs Pins. Die meisten Module haben auf der Rückseite eine Lötbrücke namens PS; ist sie geschlossen, hängt die Versorgung der IR-LED (VL) direkt an VCC, und du lässt den VL-Pin frei.

PinAufgabeAnschluss
VLVersorgungseingang der IR-LEDFrei lassen, wenn die PS-Brücke geschlossen ist
GNDMasseGND
VCCVersorgung des Chips3,3 V
SDAI2C-DatenleitungSDA-Pin des Boards
SCLI2C-TaktleitungSCL-Pin des Boards
INTInterrupt-Ausgang (Open-Drain)Ein interruptfähiger Digitalpin
Der APDS-9960 verträgt höchstens 3,6 V; VCC an den 5V-Pin des Arduino zu hängen, kann den Chip dauerhaft zerstören. Außer bei speziellen Versionen mit Spannungsregler und Pegelwandler auf der Platine versorgst du das Modul immer mit 3,3 V. Bei manchen billigen Modulen steht das nicht dabei; im Zweifel nimm 3,3 V.

Anschluss: Arduino Uno, ESP32 und Raspberry Pi Pico

APDS-9960Arduino UnoESP32Raspberry Pi Pico
VCC3.3V3V33V3 (OUT)
GNDGNDGNDGND
SDAA4 (über Pegelwandler)GPIO 21GP4
SCLA5 (über Pegelwandler)GPIO 22GP5
INTD2GPIO 4GP15
VLFrei (PS geschlossen)Frei (PS geschlossen)Frei (PS geschlossen)

ESP32 und Pico arbeiten ohnehin mit 3,3 V und werden direkt verbunden. Beim Uno ist es etwas unübersichtlicher: Die Wire-Bibliothek des Uno schaltet an SDA und SCL interne Pull-up-Widerstände ein und zieht die Leitungen Richtung 5 V, während die Widerstände des Moduls auf 3,3 V ziehen. In der Praxis klappt das meist, reizt aber die Grenzen des Chips aus. Am saubersten ist ein bidirektionaler I2C-Pegelwandler zwischen Uno und Modul. Da der INT-Pin Open-Drain ist, hält ihn der Pull-up des Moduls auf 3,3 V; der Uno erkennt diese Spannung als HIGH, deshalb brauchst du beim Uno für INT keinen internen Pull-up. Wie I2C funktioniert, erklären wir in der Anleitung Was ist I2C.

SparkFun oder Adafruit? Die Wahl der Bibliothek

MerkmalSparkFun APDS9960Adafruit APDS9960
GestenrichtungenHoch, runter, links, rechts sowie nah und fernHoch, runter, links, rechts
Näherung lesenreadProximity(Variable)Rückgabewert von readProximity()
Farbe lesenEinzelne Funktionen wie readRedLight()Alles auf einmal mit getColorData(), dazu Lux und Farbtemperatur
Interrupt-EinstellungenGesten-, Näherungs- und Licht-InterruptNäherungs- und Farb-Interrupt, Schwellwert einstellbar
Akzeptierte Chip-ID0xAB und 0x9CNur 0xAB
Zusätzliche AbhängigkeitKeine (nur Wire)Adafruit BusIO

Beide Bibliotheken findest du im Bibliotheksverwalter: Suche nach SparkFun APDS9960 RGB and Gesture Sensor und Adafruit APDS9960 Library. Bei Gesten ist der Algorithmus von SparkFun etwas stabiler und erkennt auch Nah- und Fern-Bewegungen; bei Farbe erleichtern die Lux- und Farbtemperatur-Funktionen von Adafruit die Arbeit. In dieser Anleitung nutzen wir beide. Installierst du zum ersten Mal eine Bibliothek, wirf einen Blick in die Anleitung Arduino-Bibliothek hinzufügen.

Schritt für Schritt: der erste Gestentest (mit INT-Pin)

  1. Schließe das Modul nach der Tabelle oben an: VCC an 3.3V, SDA an A4, SCL an A5, INT an D2.
  2. Installiere die SparkFun-Bibliothek und lade den folgenden Sketch auf den Uno.
  3. Öffne den seriellen Monitor mit 9600 Baud und warte auf die Meldung "Jest sensoru hazir" (Gestensensor bereit).
  4. Führe die Hand 5–10 cm über dem Sensor von einem Rand zum anderen, so schnell, dass es etwa eine halbe Sekunde dauert.
  5. Es erscheint YUKARI (hoch), ASAGI (runter), SOL (links) oder SAG (rechts); sind die Richtungen vertauscht, drehe den Sensor um 90 oder 180 Grad oder tausche die Fälle im 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}

Ist eine Geste fertig, zieht der APDS-9960 den INT-Pin auf LOW und löst damit den Interrupt am Pin D2 des Uno aus. Die Interrupt-Funktion setzt nur ein Flag; gelesen wird erst in loop(), denn readGesture() liest Dutzende Bytes über I2C, und I2C innerhalb eines Interrupts führt zu Hängern. Den Interrupt während des Lesens kurz abzuschalten, verhindert außerdem, dass dieselbe Geste zweimal verarbeitet wird. Die Logik von Interrupts findest du ausführlich in der Anleitung Arduino Interrupt.

Am besten hältst du die Hand flach und offen und führst sie in einer halben Sekunde 5–10 cm über den Sensor. Bist du zu langsam, schaltet die Gesten-Engine ab, bevor die Bewegung fertig ist; bist du zu schnell, sammeln sich nicht genug Daten im FIFO. Senkst du die Hand direkt über den Sensor und hältst sie kurz still, wird das als NEAR erkannt; hältst du sie und hebst sie dann langsam an, als FAR. Diese beiden Bewegungen sind weniger zuverlässig als die vier Richtungen.

Näherung erkennen: eine LED, die mit der Hand heller wird

Nur die Näherung statt Gesten zu messen, ist viel einfacher und stabiler. Der folgende Sketch gibt den Näherungswert per PWM direkt an eine LED weiter: Je näher die Hand, desto heller die LED, und sie wird dunkler, wenn du dich entfernst. Schließe die LED über einen 220-Ω-Widerstand an D9 an; den passenden Wert findest du mit dem LED-Vorwiderstandsrechner.

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}

Der Näherungswert ist keine Angabe in Zentimetern, sondern die Stärke des reflektierten Lichts. Ein weißes Blatt Papier liefert in 15 cm Abstand vielleicht 40, ein schwarzer Stoff bleibt im selben Abstand unter 10. Nutze den APDS-9960 daher nicht als Entfernungsmesser, sondern als Antwort auf die Frage "Ist etwas nah gekommen?". Brauchst du eine genaue Entfernung, ist der Ultraschallsensor HC-SR04 die genauere Wahl. Sind die Werte sehr niedrig, stelle die Verstärkung auf PGAIN_4X oder PGAIN_8X; klebt der Wert ständig bei 255, geh auf PGAIN_1X herunter.

RGB-Farbe und Umgebungslicht messen

Für Farbe liest der APDS-9960 vier Kanäle: Rot (R), Grün (G), Blau (B) und das ungefilterte Gesamtlicht (C). Die Adafruit-Bibliothek berechnet aus diesen Rohwerten außerdem einen ungefähren Lux-Wert und die Farbtemperatur des Lichts in Kelvin. Der folgende Sketch gibt jede halbe Sekunde die vier Kanäle, Lux und Kelvin aus und sagt, welche Farbe überwiegt.

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}

Die Rohwerte sind keine absoluten Farben, sondern Lichtmengen; dieselbe rote Karte ergibt in einem dunklen Zimmer und in der Sonne sehr unterschiedliche Zahlen. Vergleiche deshalb Verhältnisse: Das Verhältnis von R zu C bleibt auch bei wechselndem Licht stabiler. Willst du die Farbe eines Gegenstands lesen, halte ihn 1–2 cm vor den Sensor und schirme Fremdlicht mit der Hand oder einem Röhrchen ab. Der Lux-Wert ist eine Näherung; er ersetzt kein Luxmeter, reicht aber für die Frage "Ist es im Raum dunkel geworden?" völlig aus. Für Projekte mit feinerer Farbunterscheidung kommen reine Farbsensoren wie der Farbsensor TCS3200 oder der TCS34725 infrage.

LED per Geste steuern (ohne INT-Pin)

Den INT-Pin musst du nicht anschließen. Die Bibliothek kann auch durch Abfragen des Statusregisters der Gesten-Engine über I2C erkennen, ob eine neue Geste vorliegt. Das spart einen Pin und hält den Code schlicht; der Preis ist ständiger I2C-Verkehr in loop(). Im folgenden Sketch schaltet eine Geste nach oben die LED voll ein, eine Geste nach unten aus, und Gesten nach rechts und links erhöhen und senken die Helligkeit in Vierteln.

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}

Musik per Geste steuern: mit dem DFPlayer Mini

DFPlayer-Mini-MP3-Player-Modul
DFPlayer Mini: spielt MP3-Dateien von der SD-Karte und empfängt Befehle über eine serielle Leitung.

Die unterhaltsamste Anwendung eines Gestensensors ist ein berührungsloser Musikplayer. Verbinde den RX-Pin des DFPlayer Mini über einen 1-kΩ-Widerstand mit D11 des Uno und den TX-Pin mit D10; schließe den Lautsprecher an SPK_1 und SPK_2 an und versorge das Modul mit 5V. Kopiere die Lieder als 0001.mp3, 0002.mp3 und so weiter auf die SD-Karte. Details zum Modul stehen in der Anleitung DFPlayer Mini. Eine Geste nach rechts springt zum nächsten Lied, nach links zum vorherigen; Gesten nach oben und unten machen lauter und leiser, und die Hand ruhig über den Sensor zu halten, pausiert und setzt fort.

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}

Ein Detail solltest du kennen: readGesture() kehrt erst zurück, wenn die Geste vorbei ist, und wartet zwischen den FIFO-Lesevorgängen jeweils 30 ms. Solange deine Hand über dem Sensor ist, macht der Arduino nichts anderes. Für einen Musikplayer ist das kein Problem; hat derselbe Sketch aber einen Motor oder eine Display-Animation, die schnell reagieren müssen, musst du sie um das Gestenlesen herum planen.

INT-Pin und ESP32: Näherung per Interrupt erkennen

Der INT-Pin ist nicht nur für Gesten da, sondern auch für Näherungs- und Lichtschwellen. Du legst eine Schwelle fest; überschreitet ein Messwert sie, zieht der APDS-9960 INT auf LOW und hält ihn dort, bis du ihn zurücksetzt. So muss der Mikrocontroller den Sensor nicht ständig abfragen. Der folgende ESP32-Sketch löst mit der Adafruit-Bibliothek INT aus, wenn die Näherung über 150 steigt, und schaltet bei jeder Annäherung der Hand die LED auf dem Board um, wie ein berührungsloser Lichtschalter.

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}

Der dritte Parameter von setProximityInterruptThreshold() (Standard 4) ist die Persistenz: Er gibt an, wie viele Messungen hintereinander die Schwelle überschreiten müssen, bevor der Interrupt auslöst, und filtert so kurze Störungen heraus. Rufst du clearInterrupt() nicht auf, bleibt INT auf LOW, und du verpasst die nächste Annäherung. Für Akkuprojekte ist das sehr nützlich: Schick den ESP32 in den Deep Sleep und weck ihn mit esp_sleep_enable_ext0_wakeup(GPIO_NUM_4, 0) über den INT-Pin, dann wacht das Board nur auf, wenn jemand die Hand nähert. GPIO 4 ist ein RTC-Pin und eignet sich deshalb dafür.

APDS-9960 am Raspberry Pi Pico (MicroPython)

Am Raspberry Pi Pico kannst du den APDS-9960 in MicroPython ganz ohne Bibliothek betreiben, indem du direkt in seine Register schreibst. Der folgende Code liest die Chip-ID, schaltet Farb- und Näherungsmessung ein und gibt alle 200 ms die vier Farbkanäle und den Näherungswert aus. Angeschlossen wird am Bus I2C0: SDA an GP4, SCL an GP5 und VCC an den Pin 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)

Die Register im Code bedeuten Folgendes: 0x80 (ENABLE) wählt, welche Einheiten aktiv sind, 0x81 (ATIME) legt die Integrationszeit der Farbmessung fest (2,78 ms pro Schritt), 0x8F (CONTROL) bestimmt den IR-LED-Strom und die Verstärkungen, 0x93 (STATUS) meldet, ob Daten bereitstehen, 0x94–0x9B enthalten die Farbkanäle und 0x9C den Näherungswert. Für Gesten müsstest du den FIFO auslesen und einen Richtungsalgorithmus wie den von SparkFun schreiben, das ist eine größere Aufgabe. Arbeitest du lieber mit der Arduino IDE, installiere auf dem Pico den arduino-pico-Core und nutze die SparkFun-Bibliothek unverändert; die Standard-I2C-Pins sind auch dort GP4 und GP5.

Reichweitengrenze und richtige Anwendung

Der APDS-9960 wurde als Handysensor entwickelt und hat eine kurze Reichweite. In der Praxis sind Gesten zwischen 5 und 15 cm zuverlässig, bestenfalls bis 20 cm. Die Näherungsmessung liefert bis zu einem ähnlichen Abstand sinnvolle Werte. Begrenzt wird das durch die Leistung der IR-LED und dadurch, wie viel Licht deine Hand reflektiert; LED-Strom auf 100 mA und Verstärkung auf Maximum bringen etwas mehr Reichweite, aber auch mehr Rauschen.

EinflussgrößeWirkungWas tun?
AbstandÜber 15 cm verschwinden die GestenHand in 5–10 cm vorbeiführen
BewegungsgeschwindigkeitSehr langsame oder sehr schnelle Bewegungen werden nicht erkanntEine flüssige Bewegung von einer halben Sekunde
SonnenlichtDas IR im Sonnenlicht übersteuert die FotodiodenIm Schatten oder drinnen nutzen
Glas oder durchsichtige AbdeckungDie Abdeckung wirft IR zurück, die Näherung ist immer hochAbdeckung entfernen oder dünnes IR-durchlässiges Material verwenden
OberflächenfarbeEin schwarzer Handschuh reflektiert wenigerVerstärkung erhöhen
Ausrichtung des SensorsDie Richtungen drehen sichRichtungsfälle im Code tauschen

Projektideen mit dem APDS-9960

  • Berührungslose Lampe: Schalte mit dem Näherungs-Interrupt ein Relaismodul ein und aus; sehr praktisch in der Küche, wenn die Hände schmutzig sind.
  • Farblampe per Geste: Blättere mit Gesten nach rechts und links durch die Farben einer RGB-LED oder eines WS2812B-Streifens.
  • Menü in der Luft: Wähle mit Gesten nach oben und unten Einträge auf einem OLED-Display und bestätige mit NEAR.
  • Servo-Deckel per Geste: Öffne den Deckel einer Box per Geste mit einem Servomotor.
  • Automatische Display-Helligkeit: Passe Bildschirm oder LED-Streifen an das Umgebungslicht an; im Vergleich zum LDR bekommst du stabilere Werte mit Farbinformation.
  • Farbsortierer: Sortiere bunte Bonbons oder Bausteine, die eine Rutsche herunterkommen, nach ihren Farbkanälen.

Häufige Fehler und Lösungen

SymptomWahrscheinliche UrsacheLösung
"APDS-9960 bulunamadi" (nicht gefunden)Verdrahtungsfehler, keine 3,3 V oder andere Chip-IDMit I2C-Scanner nach 0x39 suchen, ID auslesen
Modul gefunden, aber init schlägt fehlNachbau-Chip mit anderer ID wie 0xA8Diesen Wert in die ID-Prüfung der Bibliothek aufnehmen
Gar keine GestenHand zu weit weg oder zu langsam, VL ohne VersorgungIn 5–10 cm in einer halben Sekunde vorbeiführen, PS-Brücke prüfen
Richtungen vertauscht oder durcheinanderEinbaulage des SensorsDIR-Fälle im Code tauschen
Näherung ständig hochGlas, Abdeckung oder nahe Fläche davorAbdeckung entfernen, Verstärkung senken
Funktioniert draußen nichtSonnenlicht überdeckt das IRIm Schatten nutzen
Zufällige Hänger am UnoI2C-Pegel 5 V und 3,3 V passen nicht, lange KabelPegelwandler und kurze Kabel
INT bleibt auf LOWInterrupt nicht zurückgesetztNach dem Lesen clearInterrupt() aufrufen
Bei Problemen prüfe zuerst mit einem I2C-Scanner-Sketch, ob die Adresse 0x39 auftaucht, und lass dann den einfachen Code laufen, der nur die Näherung liest. Steigt der Wert von 0 auf über 200, wenn du die Hand näherst, ist die Hardware in Ordnung, und das Problem liegt bei den Gesteneinstellungen oder deiner Handbewegung.

Mit einem kleinen Modul bringt der APDS-9960 berührungslose Steuerung, Näherungserkennung und Farbmessung in dein Projekt. Behältst du die kurze Reichweite und die 3,3-V-Regel im Kopf, wird er zu einem zuverlässigen Bedienelement. In der BlueGrays-App findest du Projekte zu RGB-LED, Lichtmessung mit LDR, Bewegungsmelder und Entfernungsmessung mit Schaltplan und Code Schritt für Schritt und kannst sie mit dem APDS-9960 zu berührungslosen Versionen erweitern.

Häufige Fragen

Funktioniert der APDS-9960 mit 5 V?

Nein, der APDS-9960 arbeitet mit 2,4–3,6 V, und 5 V können ihn beschädigen. Versorge das Modul über den 3.3V-Pin des Arduino Uno und setze nach Möglichkeit einen Pegelwandler in die Leitungen SDA und SCL. Nur spezielle Versionen, bei denen ausdrücklich ein Spannungsregler und Pegelwandler angegeben sind, vertragen 5 V.

Welche I2C-Adresse hat der APDS-9960?

Die I2C-Adresse des APDS-9960 ist 0x39 und lässt sich nicht ändern. Deshalb kannst du keine zwei APDS-9960 an denselben I2C-Bus hängen; brauchst du zwei Sensoren, nimm einen I2C-Multiplexer wie den TCA9548A oder den zweiten I2C-Bus von ESP32 oder Pico.

Wie groß ist die Gestenreichweite des APDS-9960?

In der Praxis werden Gesten zwischen 5 und 15 cm zuverlässig erkannt, unter guten Bedingungen bis 20 cm. Die Reichweite hängt davon ab, wie viel Licht deine Hand reflektiert, vom IR-LED-Strom und von der Verstärkung. Sonnenlicht und Glas vor dem Sensor verringern die Reichweite deutlich.

Muss der INT-Pin des APDS-9960 angeschlossen werden?

Nein. Die Bibliotheken können Gesten und Näherung auch per Abfrage über I2C lesen; bei SparkFun erledigt das enableGestureSensor(false). Der INT-Pin meldet ein Ereignis aber sofort, ohne ständige Abfrage, entlastet so den Prozessor und kann einen ESP32 aus dem Tiefschlaf wecken.

Wie genau misst der APDS-9960 Farben?

Der APDS-9960 misst seine Farbkanäle mit 16 Bit Auflösung, liefert aber vom Umgebungslicht abhängige Rohwerte statt absoluter Farben. Hältst du einen Gegenstand nah davor und schirmst Fremdlicht ab, unterscheidet er rote, grüne und blaue Karten problemlos. Für feinere Farbunterscheidung sind reine Farbsensoren wie TCS34725 oder TCS3200 besser geeignet.

Warum meldet der APDS-9960 init failed?

Dieser Fehler bedeutet, dass die Bibliothek die ID des Sensors nicht lesen konnte oder nicht den erwarteten Wert gefunden hat. Prüfe Verkabelung, 3,3-V-Versorgung und ob SDA und SCL vertauscht sind, und suche dann mit einem I2C-Scanner nach der Adresse 0x39. Taucht sie auf, ist der Chip vielleicht ein Nachbau; lies den Wert im ID-Register und ergänze ihn in der Liste, die die Bibliothek akzeptiert.

Alle Projekte ansehen
Lichtstärke messen mit LDR
AR-11Anfänger

Lichtstärke messen mit LDR

Willst du sehen, wie hell dein Zimmer ist, und zwar als Zahl? Der LDR, ein kleines lichtempfindliches Bauteil, misst das Umgebungslicht, und der Arduino schreibt den Wert jede halbe Sekunde auf…

4.6(83)
143
RGB-LED verwenden
AR-39Anfänger
Premium

RGB-LED verwenden

In einer einzigen LED stecken drei Farben: Die RGB-LED leuchtet erst rot, dann grün, dann blau, jede Farbe eine halbe Sekunde an und eine halbe Sekunde aus, und dann geht es von vorne los.

4.9(73)
100
Sanfte Farbübergänge mit RGB-Led
AR-40Anfänger
Premium

Sanfte Farbübergänge mit RGB-Led

Eine einzige RGB-LED wandert langsam von Rot zu Grün, von Grün zu Blau und wieder zurück zu Rot, eine Regenbogenschleife ohne Ende.

4.8(58)
78
Bewegungsmelder mit Bewegungssensor
AR-24Anfänger
Premium

Bewegungsmelder mit Bewegungssensor

Ein einfacher Wächter, der Bescheid gibt, wenn jemand den Raum betritt. Der Bewegungsmelder spürt die Wärme, die der menschliche Körper abgibt; der Arduino lässt die LED leuchten, solange sich etwas…

4.6(47)
67
Türklingel und Licht mit Bewegungssensor
AR-25Mittel
Premium

Türklingel und Licht mit Bewegungssensor

Kommt jemand an deine Tür, weißt du es, bevor er klingelt. Sobald der Bewegungsmelder jemanden bemerkt, leuchtet die LED und der Summer spielt einen Gong aus drei Tönen, von hoch nach tief; ist die…

4.7(54)
72
Reflexion (Nähe) mit TCRT5000 messen
AR-77Mittel
Premium

Reflexion (Nähe) mit TCRT5000 messen

Mit einem kleinen Sensor, der unsichtbares Licht aussendet und misst, wie viel davon zurückkommt, erkennst du die Fläche vor ihm.

4.6(33)
43
ESP32 RGB-LED-Steuerung
ES-9Anfänger

ESP32 RGB-LED-Steuerung

Unbegrenzte Farberzeugung mit einer einzigen RGB-LED anstelle von 3 separaten LEDs. Wie in Arduino machen wir Regenbogenübergänge, indem wir R/G/B-Werte mit analogWrite() setzen. Die Farbtheorie (z. B. Rot+Grün=Gelb) wird praktisch umgesetzt.

4.6(29)
52
ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)
ES-37Fortgeschritten
Premium

ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)

Mit ESP32, PIR-Bewegungssensor, LDR-Lichtsensor und Relaismodul machen wir aus Flur, Bad oder Vorratskammer eine smarte Beleuchtung. Ist es hell, bleibt das Licht trotz Bewegung aus, so brennt es tagsüber nicht umsonst und spart Energie. Das Licht bleibt 30 Sekunden an; solange Bewegung erkannt wird, verlängert sich die Zeit automatisch.

4.3(6)
11