APDS-9960 e Arduino. Rilevamento di gesture con modulo economico

Ciao!

Questa è la mia guida per utilizzare il sensore APDS-9960, nello specifico affronterò la modalità "rilevamento gesture".
Questo componente infatti permette di rilevare la prossimità, il colore e le gesture fatte muovendo una mano sopra di esso ("UP", "DOWN", "RIGHT", "LEFT", "NEAR" e "FAR").

Il sensore viene montato su moduli da vari produttori,
Sparkfun e Adafruit quelli più noti, ma si trovano (su eBay ad esempio) vari moduli più economici.
Io ho acquistato su eBay un modulo simile a questo.



Vediamo subito come utilizzare il modulo con il nostro Arduino.
Per prima cosa collegate il modulo come mostrato in questo schema:



La libreria più popolare per utilizzare questi moduli è quella fornita da Sparkfun (la trovate qui), ovviamente questa libreria è sviluppata per i moduli forniti dallo stesso produttore dove ne garantisce la compatibilità.

Nel mio caso, con il modulo preso su eBay, ho avuto problemi ad utilizzare le gesture.
Infatti ho notato che caricando l'esempio "GestureTest" dalla libreria di Sparkfun, non appariva nessuna gesture.

Cercando un po' su internet non ho trovato granchè, quindi ho deciso di provare a capire quale fosse il problema.
Ho fatto alcune modifiche alla libreria di Sparkfun, ho abilitato il debug, ridotto la potenza del led ed ho aggiunto alcune funzioni.

Per procedere scaricate ed installate la libreria modificata che trovate qui.
Avendo abilitato il debug, ora sul serial monitor appariranno delle informazioni simile a quelle che vedete qui sotto


Il sensore, per capire il movimento della mano, necessita che i suoi 4 fotodiodi si comportino nello stesso modo.
Per provare il comportamento dei fotodiodi, ho messo un pezzo di cartoncino fermo davanti al modulo, in modo da far leggere ai 4 fotodiodi lo stesso valore.
Come potete vedere dai dati cerchiati il valore non è simile a tutti e 4, ma il Left è molto diverso dal Right, questo comporta degli errori nell'analisi della gesture.

Per correggere questo squilibrio, decommentate una delle righe dalla 90 alla 93 del codice qui sotto in base ad i valori letti sul vostro serial monitor, il valore tra parentesi è l'offset, il valore che inserite andrà a ridurre il valore letto.
Quindi se volete che il valore di Left sia simile a Right, dovete scrivere apds.setGestureOffset_R(5); Dove "5" è un valore con cui andrete a ridurre il valore di R. Purtroppo non andrete a togliere esattamente "5" ad "R" quindi dovete procedere per tentativi prima di trovare il valore corretto.


  1. /****************************************************************
  2. GestureTest.ino
  3. APDS-9960 RGB and Gesture Sensor
  4. Shawn Hymel @ SparkFun Electronics
  5. May 30, 2014
  6. https://github.com/sparkfun/APDS-9960_RGB_and_Gesture_Sensor
  7. Tests the gesture sensing abilities of the APDS-9960. Configures
  8. APDS-9960 over I2C and waits for gesture events. Calculates the
  9. direction of the swipe (up, down, left, right) and displays it
  10. on a serial console.
  11. To perform a NEAR gesture, hold your hand
  12. far above the sensor and move it close to the sensor (within 2
  13. inches). Hold your hand there for at least 1 second and move it
  14. away.
  15. To perform a FAR gesture, hold your hand within 2 inches of the
  16. sensor for at least 1 second and then move it above (out of
  17. range) of the sensor.
  18. Hardware Connections:
  19. IMPORTANT: The APDS-9960 can only accept 3.3V!
  20.  Arduino Pin  APDS-9960 Board  Function
  21.  3.3V         VCC              Power
  22.  GND          GND              Ground
  23.  A4           SDA              I2C Data
  24.  A5           SCL              I2C Clock
  25.  2            INT              Interrupt
  26. Resources:
  27. Include Wire.h and SparkFun_APDS-9960.h
  28. Development environment specifics:
  29. Written in Arduino 1.0.5
  30. Tested with SparkFun Arduino Pro Mini 3.3V
  31. This code is beerware; if you see me (or any other SparkFun
  32. employee) at the local, and you've found our code helpful, please
  33. buy us a round!
  34. Distributed as-is; no warranty is given.
  35. ****************************************************************/
  36. #include <Wire.h>
  37. #include <SparkFun_APDS9960.h>
  38. // Pins
  39. #define APDS9960_INT    2 // Needs to be an interrupt pin
  40. // Constants
  41. // Global Variables
  42. SparkFun_APDS9960 apds = SparkFun_APDS9960();
  43. int isr_flag = 0;
  44. void setup() {
  45.   // Set interrupt pin as input
  46.   pinMode(APDS9960_INT, INPUT);
  47.   // Initialize Serial port
  48.   Serial.begin(9600);
  49.   Serial.println();
  50.   Serial.println(F("--------------------------------"));
  51.   Serial.println(F("SparkFun APDS-9960 - GestureTest"));
  52.   Serial.println(F("--------------------------------"));
  53.   // Initialize interrupt service routine
  54.   attachInterrupt(0, interruptRoutine, FALLING);
  55.   // Initialize APDS-9960 (configure I2C and initial values)
  56.   if ( apds.init() ) {
  57.     Serial.println(F("APDS-9960 initialization complete"));
  58.   } else {
  59.     Serial.println(F("Something went wrong during APDS-9960 init!"));
  60.   }
  61.   // Start running the APDS-9960 gesture sensor engine
  62.   if ( apds.enableGestureSensor(true) ) {
  63.     Serial.println(F("Gesture sensor is now running"));
  64.   } else {
  65.     Serial.println(F("Something went wrong during gesture sensor init!"));
  66.   }
  67.   //Correzione dell'offset dei sensori. aumentando l'offset il valore letto si riduce
  68.   //apds.setGestureOffset_U(0);
  69.   //apds.setGestureOffset_D(0);
  70.   //apds.setGestureOffset_L(0);
  71.   //apds.setGestureOffset_R(0);
  72. }
  73. void loop() {
  74.   if( isr_flag == 1 ) {
  75.     detachInterrupt(0);
  76.     handleGesture();
  77.     isr_flag = 0;
  78.     attachInterrupt(0, interruptRoutine, FALLING);
  79.   }
  80. }
  81. void interruptRoutine() {
  82.   isr_flag = 1;
  83. }
  84. void handleGesture() {
  85.     if ( apds.isGestureAvailable() ) {
  86.     switch ( apds.readGesture() ) {
  87.       case DIR_UP:
  88.         Serial.println("UP");
  89.         break;
  90.       case DIR_DOWN:
  91.         Serial.println("DOWN");
  92.         break;
  93.       case DIR_LEFT:
  94.         Serial.println("LEFT");
  95.         break;
  96.       case DIR_RIGHT:
  97.         Serial.println("RIGHT");
  98.         break;
  99.       case DIR_NEAR:
  100.         Serial.println("NEAR");
  101.         break;
  102.       case DIR_FAR:
  103.         Serial.println("FAR");
  104.         break;
  105.       default:
  106.         Serial.println("NONE");
  107.     }
  108.   }
  109. }

A questo punto, il modulo "funziona", ma devo dire che pensavo fosse più rapido nel rilevamento delle gesture, la mano deve fare un movimento molto lento per permettere una corretta interpretazione della gesture.

Questo è tutto!
Segui Daniele Alberti su Google+ per rimanere sempre aggiornato su nuovi post.

Nessun commento:

Posta un commento

Lascia un commento qui sotto, ti risponderò il prima possibile!

Altri Post