Avago APDS-9960 Gestensensor

[Joachim D. (rockjoe)]

Hallo zusammen,

seit einigen Wochen versuche ich verzweifelt ein Register des APDS-9960 
Gestensensors über I2C richtig auszulesen und nutze zur Programmierung 
eines ATmega328P Atmel Studio 7 und einen AVR ISP MKII als Programmer.

Leider schlägt das Auslesen des Registers 0xAE, welches angibt, wieviele 
Gesten Datensätze bereits in den internen FIFO geladen wurden, fehl.
Zum Auslesen benutze ich das I2C Read Protocol Combined Format, wie es 
auch im Datenblatt des Sensors auf S.8 angegeben ist.

Datenblatt APDS-9960: http://www.avagotech.com/docs/AV02-4191EN

In der while-Schleife des Hauptprogramms lese ich das Register 0xAE 
regelmäßig aus - ohne Delay.
Wenn ich nun mit der Hand über den Sensor kurz wische, erhalte ich 
folgende Ausgabe, die über die UART-Schnittstelle realisiert ist:

"
FIFO Level: 16
FIFO Level: 16
FIFO Level: 16
FIFO Level: 16
FIFO Level: 16
FIFO Level: 16
FIFO Level: 16
FIFO Level: 1
FIFO Level: 16
FIFO Level: 16
FIFO Level: 16
FIFO Level: 16
FIFO Level: 16
FIFO Level: 16
FIFO Level: 16
FIFO Level: 16
FIFO Level: 16
FIFO Level: 16
FIFO Level: 1   "

Also in sehr unregelmäßigen Abständen ändert sich der Wert für 
FIFO-Level. Dieser ändert sich aber laut Datenblatt NUR, WENN man den 
FIFO auch tatsächlich ausliest, was ich aber nicht mache.
Die Interrupts, die der Sensor selbst auslösen könnte, habe ich in der 
Initialisierung ALLE deaktiviert. Also auch das kann nicht die Ursache 
sein.


Das einzige, was ich mir vorstellen kann, ist, dass mein Mikrocontroller 
hin und wieder vll den Wert des falschen Registers zurückbekommt. Denn 
das auf 0xAE folgende Register 0xAF enthält zwei Status-Flags "GFIFO_OV" 
und "GVALID".
Das Flag GVALID wird "1", sobald FIFO-Level einen bestimmten, 
konfigurierten Wert übersteigt.


Meine I2C Combined Read Protocol Funktion scheint auch zu funktionieren 
und liefert mir folgende Statuscodes zurück:

0x8
0x18
0x28
0x10
0x40
0x58



Hat jemand vielleicht ne Idee?
Bin für jeden Hinweis dankbar.

[Joachim (Gast)]

Inzwischen habe ich meine I2C Ausleseroutine auch mit einem anderen, 
auslesbaren Register des APDS-9960 ausprobiert.

Auch hier scheint mir der APDS mal den Wert des Registers Nummer "x" und 
ab und zu den des Registers Nummer "x+1" zurückzugeben.

Meine I2C Lesertoutine sieht wie folgt aus:

uint8_t read_APDS9960(uint8_t reg)
{
  //uart_puts("In function read_APDS9960.\n");
  uint8_t reg_value = 0;
  
  char buffer[10];
  
  uint8_t twst_start;      //flag to check whether the START condition has been transmitted successfully
  uint8_t twst_start_2;    //flag to check whether the second START condition has been transmitted successfully
  uint8_t twst_sla_addr;    //flag to check whether the slave device plus W-Bit has been transmitted successfully
  uint8_t twst_sla_addr_2;  //flag to check whether slave address plus R-Bit has been transmitted successfully
  uint8_t twst_reg_addr;    //flag to check whether the register address of slave could be addressed successfully
  uint8_t twst_ma_answer;    //flag to check the master's response: ACK or NACK
  
  //////////---Begin of Read Protocol Combined Format---//////////
  
  //---send START condition----------------------------//
  //uart_puts("Sending START condition...\n");
  TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTA);
  while(!(TWCR & (1<<TWINT)));
  twst_start = TW_STATUS;
  if(twst_start != TW_START)
  {
    uart_puts("Failed to send START...\n");
    TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO);
    while((TWCR & (1<<TWSTO)));
    return false;
  }

  
  //---send slave's address plus R/W Bit---------------//
  //uart_puts("Sending SLA+W...\n");
  TWDR = ((APDS9960_I2C_ADDR<<1) | TW_WRITE);
  TWCR = (1<<TWEN) | (1<<TWINT);
  while(!(TWCR & (1<<TWINT)));
  twst_sla_addr = TW_STATUS;
  if(twst_sla_addr != TW_MT_SLA_ACK)
  {
    uart_puts("Failed to send SLA+W...\n");
    TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO);
    while((TWCR & (1<<TWSTO)));
    return false;
  }

  
  //---send address of the register to read from--------//
  //uart_puts("Sending register address...\n");
  TWDR = reg;
  TWCR = (1<<TWEN) | (1<<TWINT);
  while(!(TWCR & (1<<TWINT)));
  twst_reg_addr = TW_STATUS;
  if(twst_reg_addr != TW_MT_DATA_ACK)
  {
    uart_puts("Failed to send register address...\n");
    TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO);
    while((TWCR & (1<<TWSTO)));
    return false;
  }

  
  //---send START condition----------------------------//
  //uart_puts("Sending REPEATED START condition...\n");
  TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTA);
  while(!(TWCR & (1<<TWINT)));
  twst_start_2 = TW_STATUS;
  if(twst_start_2 != TW_REP_START)
  {
    uart_puts("Failed to send REPEATED START...\n");
    TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO);
    while((TWCR & (1<<TWSTO)));
    return false;
  }

  
  //---send slave's address plus R/W Bit---------------//
  //uart_puts("Sending SLA+R...\n");
  TWDR = ((APDS9960_I2C_ADDR<<1) | TW_READ);
  TWCR = (1<<TWEN) | (1<<TWINT);
  while(!(TWCR & (1<<TWINT)));
  twst_sla_addr_2 = TW_STATUS;
  if(twst_sla_addr_2 != TW_MR_SLA_ACK)
  {
    uart_puts("Failed to send SLA+R...\n");
    utoa(twst_sla_addr_2, buffer, 16);
    uart_puts("0x");
    uart_puts(buffer);
    uart_puts("\n");
    TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO);
    while((TWCR & (1<<TWSTO)));
    
    return false;
  }

  
  //---receive data from the previous addressed register and return NACK----//
  //uart_puts("Receiving data from slave...\n");
   TWCR = (1<<TWEN) | (1<<TWINT);
   while(!(TWCR & (1<<TWINT)));
  _delay_ms(100);
  reg_value = TWDR;
  twst_ma_answer = TW_STATUS;
  if(twst_ma_answer != TW_MR_DATA_NACK)
  {
    TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO);
    while((TWCR & (1<<TWSTO)));
    return false;
  }

  
  //---send a STOP condition---------------------------//
   TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO);
   while((TWCR & (1<<TWSTO)));
  
  //////////---End of Read Protocol Combined Format---//////////
  
  
  
  //--print TWI status reports to screen
  
   uart_puts("Printing TWI status flags of Read Protocol Combined Format...\n");
   
   utoa(twst_start, buffer, 16);
   uart_puts("0x");
   uart_puts(buffer);
   uart_puts("\n");
   
   utoa(twst_sla_addr, buffer, 16);
   uart_puts("0x");
   uart_puts(buffer);
   uart_puts("\n");
   
   utoa(twst_reg_addr, buffer, 16);
   uart_puts("0x");
   uart_puts(buffer);
   uart_puts("\n");
   
   utoa(twst_start_2, buffer, 16);
   uart_puts("0x");
   uart_puts(buffer);
   uart_puts("\n");
   
   utoa(twst_sla_addr_2, buffer, 16);
   uart_puts("0x");
   uart_puts(buffer);
   uart_puts("\n");
   
   utoa(twst_ma_answer, buffer, 16);
   uart_puts("0x");
   uart_puts(buffer);
   uart_puts("\n");
   uart_puts("\n");
  
  return reg_value;
}

Ich weiß echt nicht mehr weiter...

[hp-freund (Gast)]

Erste Frage wäre: hast Du den selbst gelötet?

Ich hatte so was Mal mit einem ähnlich "großen" I2C RGB Sensor.
Auch alle Pins unter dem Gehäuse :-(

Den hatte ich einfach gekillt.
Der Nächste hat dann funktioniert.

[Joachim D. (rockjoe)]

Hi,
danke für Deine Rückmeldung, hp-freund.

Den habe ich nicht selbst gelötet. Der ist von SparkFun auf einem 
Breakout Board.

Habe 4 Stück von denen bei Exp-Tech bestellt und mal einen der anderen 
ausprobiert. Bei dem anderen funktioniert die Registerauslese ohne 
Probleme.

Hab mich ca. 8 Wochen lang jeden Abend 3-4 Stunden damit beschäftigt das 
Problem zu suchen und jetzt durch einen einfachen Austausch durch ein 
anderes Exemplar das Problem gelöst.
Komisch war nur, dass er mit der SparkFun Library für Arduino zu 
funktionieren schien.

Jetzt hat sichs in meinem eigenen AVR Programm rausgestellt, dass er auf 
das NACK nicht richtig reagiert.

[Klars (Gast)]

Hallo
habe mir auch so ein Teil zugelegt und bin am testen was kommt.
Nach deinem letzten Eintrag funktioniert es jetzt. Stimmt das immer 
noch?

LG Klars

[Joe (Gast)]

Nabend,

jo. Konnte mit Hilfe der Avago Referenz-Software (die ich per E-Mail 
angefragt hatte) das gute Stück auch unter dem Raspberry Pi zum Laufen 
bringen :)
Ist echt ein tolles Sensor-IC.

[Klars (Gast)]

Bin am staunen was du so alles hast. Kannst du die Software 
weiterleiten?

[Joe (Gast)]

Sorry, aber ich weiß nicht, ob ich die ohne Genehmigung von Avago 
Technologies weiterleiten darf. Denn diese Software wird auch auf deren 
offiziellem Referenzdesign verwendet.

Falls Du nicht weiterkommst und die Kommunikation zum Sensor-IC nicht 
hinbekommst, kannst Du Dich aber jederzeit wieder melden.


Gruß
Joe

[Klars (Gast)]

Hast du mal die Adresse bzw. genauen Namen dazu? Auch nicht als private 
Nutzung? Kann doch auch mal fragen. Ansonsten komme ich gern auf den 
Angebot zurück.
Leider sind die Infos dazu nicht sehr zahlreich.
LG Kl

[Joe (Gast)]

Hi,

ich glaube, dass ich damals einfach an den Support von Avago geschrieben 
habe und bei Leuten gelandet bin, die mir weitere Application Notes und 
Infos liefern konnten.
Versuch mal folgenden Link:

https://www.broadcom.com/products/optical-sensors/integrated-ambient-light-and-proximity-sensors/apds-9960

Und dann rechts oben auf "Request Info".

Gruß

[Alex (Gast)]

Hi,
ich habe mir das Sparkfun Modul ebenfalls besorgt. Mikrocontroller sind 
leider mehr oder weniger Neuland für mich, weshalb ich aktuell mit einem 
Arduino Uno (ebenfalls ATMEGA328p) am rumtesten bin.
Ich habe vor die Gestenkontrolle in Kombination mit dem Näherungssensor 
in einem Programm zu nutzen, aber irgendwie bekomme diese Kombination 
nicht ordentlich hin. So wirklich schlau werde ich aus dem Datenblatt 
auch nicht. Die Gesten würde ich gerne zum Schalten benutzen, während 
ich über den Näherungswert dimmen möchte. Aber egal, wie ich das 
Programm nun aufbaue (z.B. Geste per Interrupt / Feststellung der 
Näherung alle z.B. 100ms)habe ich das Problem, dass es zu "race 
conditions" kommt. Z.B. erhalte ich einen Näherungswert, wenn ich eine 
Geste auslösen möchte, oder eine Geste (near / far), wenn ich eigentlich 
dimmen möchte - was auch logisch ist, weil irgendwann ist man leider 
immer im faschen Programmteil. Dadurch wird das alles relativ 
unzuverlässig. Gibt es eine Möglichkeit die Gestenauswertung 
abzubrechen, wenn innerhalb von x ms keine Geste erkannt wurde? Dann 
könnte ich nach einem Interrupt, wenn keine Geste erkannt wird, immer 
noch die Annäherung prüfen.
Oder habt ihr einen Ansatz, was ich ausprobieren könnte?
Gruß
Alex

[Joe (Gast)]

Hi,

@Alex: "race conditions" habe ich im Zusammenspiel mit dem Arduino und 
der SparkFun Library noch nie gesehen.

So, wie ich Dich verstanden habe, willst Du anscheinend eine Lichtquelle 
unter Zuhilfenahme des APDS-9960 als Bedienschnittstelle ansteuern. 
Korrekt?

Bevor Du drauf los programmierst und implementierst, sollte zunächst 
geklärt werden, welche Geste Du für welche Funktion (Dimmen, ein/aus, 
Farbe etc. ...) nutzen willst.
Weiterhin solltest Du Dir ein Bedienkonzept überlegen (z.B. ein 
FlowChart), in welchem hervorgeht, wann was in Deinem Programm passieren 
kann/soll/darf. Welche Zeitverzögerungen (Delays) sollen zwischen 
einzelnen Programmanweisungen herrschen.

Fange am besten mal damit an und hänge am besten ein Bild mit dem 
Programm-Ablauf hier mit an Deinen nächsten Beitrag an.


Gruß
Joe

[Alex (Gast)]

Hi Joe,

vielen Dank für deine Antwort. Leider habe ich diese erst jetzt gesehen 
- ich sollte mich hier mal anmelden, damit ich auch per E-Mail 
benachrichtigt werde. ;-) Genau, im Prinzip möchte ich mehrere 
Lichtquellen mit den Sensorsignalen steuern. Für eine Variante stelle 
ich mir vor, dass ich über die Gesten "right" / "left" zwei Quellen 
ansteuern kann bzw. zwischen diesen umschalte. Die Geste "up" / "down" 
würde ich benutzen, um alle Quellen auszuschalten. Das funktioniert 
soweit auch. Über die Annäherungswerte sollen die Quellen gedimmt 
werden. Hierzu möchte ich diverse Grenzwerte nutzen, die ich noch 
festlegen muss - z.B. Rückgabewert 0-20 "tue nichts", 20-120 "dimme 
runter, solange in dem Bereich", 121-255 "dimme hoch, solange in dem 
Bereich". Auch das funktioniert in einem einzelnen Sketch gut.

In der Zwischenzeit habe ich mehrere Ansätze verfolgt - ursprünglich 
dachte ich mir, dass es eine gute Idee sei mit Interrupts zu arbeiten. 
Der Controller wird zwar außer für die PWM für nichts anderes genutzt, 
aber ich dachte mir, dass die Umsetzung mit Interrupts "schöner" wäre. 
Die Idee war, dass ich abwarte, ob der APDS auch nach einer gewissen 
Zeit (z.B. nach 500ms) noch Interrupt "wirft". In dem Fall würde ich mit 
der Dimmung beginnen. Sollten in weniger als 500ms keine weiteren 
Interrupts folgen, dann schaue ich mir an, ob eine Geste vorhanden ist & 
reagiere entsprechend. Irgendwie konnte ich das im Programm leider nicht 
umsetzen. Wahrscheinlich mache ich irgendeinen blöden Gedankenfehler?

Ich habe dann noch einmal von vorne begonnen und habe das Ganze ohne 
Interrupts umgesetzt. Zunächst habe ich den Gestensensor aktiviert und 
lese über diesen dann regelmäßig den Näherungswert aus. Wenn dieser über 
einer gewissen Grenze liegt, starte ich mit dem weiteren Programmablauf. 
Das läuft eigentlich wie oben schon beschrieben ab - ich durchlaufe eine 
Schleife solange mein Näherungswert über einer gewissen Grenze liegt. 
Wenn ich dann feststelle, dass ich seit > 500ms in diesem Bereich bin, 
beginne ich mit der Dimmung. Nach dem Ende der Schleife schaue ich dann 
nur, wie lange ich in dem Bereich war. Bei < 500ms schaue ich mir an, ob 
ich eine Geste zurückerhalte. Ich hatte dann noch das Problem, dass 
Gesten nach einer Dimmung erst nach einer Wiederholung erkannt wurden 
(Rückgabewert war zunächst immer "keine Geste") - daher habe ich nach 
dem Ende des Dimmens die Geste "resettet", indem ich probiert habe sie 
auszulesen. Schöner wäre es natürlich nach dem Ende des Dimmens alle 
Parameter korrekt zu resetten.

Die "race conditions", die ich zu Anfang mal festgestellt habe, hingen 
definitiv mit meinem Programm zusammen. Manchmal sollte man, wie du 
schon geschrieben hast, erst nachdenken (Flowchart etc.), bevor man 
loslegt - gerade als Einsteiger in dem Bereich... :-)
Ich werde mir die Variante mit den Interrupts noch einmal anschauen. Das 
erscheint mir einfach sinnvoller zu sein? Oder was meint ihr?

Gruß
Alex

[Alex (Gast)]

@all: Nachdem ich nun "Dimme" durch die eigentliche Funktion ersetzt 
habe, ist mir aufgefallen, dass mir die "readProximity" Funktion aus der 
Sparkfun Library zwar einen Wert zurückliefert, wenn sich die Hand über 
dem Sensor befindet. Dieser Wert hat aber nichts mit dem Näherungswert 
zu tun. Daher muss entsprechend erst der Sensor auf die Funktion 
"Näherungssensor" umgestellt werden... Das als Info.

[Joe (Gast)]

Alex schrieb:
> Nachdem ich nun "Dimme" durch die eigentliche Funktion ersetzt
> habe, ist mir aufgefallen, dass mir die "readProximity" Funktion aus der
> Sparkfun Library zwar einen Wert zurückliefert, wenn sich die Hand über
> dem Sensor befindet. Dieser Wert hat aber nichts mit dem Näherungswert
> zu tun. Daher muss entsprechend erst der Sensor auf die Funktion
> "Näherungssensor" umgestellt werden... Das als Info.

Das stimmt so nicht ganz. Die SparkFun Funktion "readProximity" liest 
auf jeden Fall den Wert im PDATA Register, welcher auch den 
Näherungswert repräsentiert.

Deine Vorgehensweise klingt- soweit ich es zumindest verstanden habe - 
grundlegend nicht falsch. Aber es sollte auf jeden Fall möglich sein, 
zum einen über den Proximity-Wert zu dimmen und Gesten-Events 
auszuwerten ohne, dass diese wiederholt erfolgen müssen.

Um den APDS-9960 individueller verwenden zu können, rate ich Dir diesen 
entweder mit einem blanken Atmel Mikrocontroller (z.B. ATMega8) oder dem 
Raspberry Pi anzusteuern und Dir Deine eigene Library aufzusetzen. So 
habe ich persönlich damals am meisten gelernt und hatte dann auch mehr 
Spielraum beim Gestalten meines Programms. Bei der SparkFun-Library 
läuft man nämlich Gefahr, nicht zu wissen, was alles im Hintergrund im 
Mikrocontroller abläuft und was warum wie gemacht wird. Studiere 
sorgfältig das Datenblatt des APDS-9960, insbesondere die GESTURE ENGINE 
auf Seite 15 des Datenblatts.

Sobald Du die I2C-Kommunikation mit dem Sensor, die Register im Sensor 
und deren Verwendung verstanden hast, musst Du die erhaltenen 
Sensorwerte nur noch richtig verarbeiten. Bei den Gestensignalen im 
Gesten-Register musst Du dann eine Kreuzkorrelation durchführen, um 
unterschiedliche Gesten zu klassifizieren.
Studiere daher erst sorgfältig das Datenblatt und setze Dir Deine eigene 
Library auf. Zum ersten Rumspielen und Testen ist die SparkFun Library 
sicher gut. Aber zum Verständnis musst Du Dich geduldig selbst mit dem 
Datenblatt des Sensors auseinandersetzen und viel probieren.

[Andre (Gast)]

Hallo zusammen,
ich stehen auch vor dem Problem, dass ich die Gestensteuerung nicht zum 
Laufen bekomme.

Hat irgendjemand eine Lösung?

[Joe (Gast)]

Andre schrieb:
> Hallo zusammen,
> ich stehen auch vor dem Problem, dass ich die Gestensteuerung nicht zum
> Laufen bekomme.
>
> Hat irgendjemand eine Lösung?

Eine genaue Beschreibung der Vorgehensweise sowie der 
Fehlermeldungen/Probleme wäre hier angebracht, Andre.

Was für ein Board verwendest Du zur Kommunikation mit dem APDS-9960?
Arduino Uno/Leonardo... Raspberry Pi, Banana Pi, Beagle Board...?

[Andre (Gast)]

Entschuldigung für meine knappe bzw. nicht vorhandene Beschreibung.

Ich benutze nach Kl46Z von Freescale und das Programm Kinetis Design 
Studio.
Ich habe bereits mit dem Proximity Sensor gearbeitet und dieser 
funktioniert auch.
Nun ist mein Ziel die Gestensteuerung...
Ich habe versucht den C++ Code, vorhandener Arduino Projekte, in C Code 
umzuschreiben und dann mit meinem Board zu nutzen... Hat jedoch nicht 
funktioniert.

Mein Problem ist aktuell, dass ich die Funktionsweise der 
Gestensteuerung nicht verstehe.

->Deshalb suche ich ein Programm für mein Entwicklungsboard um die 
Funktion nachvollziehen zu können.

Hättet ihr dazu etwas für mich?

Viele Grüße
Andre

[Klars (Gast)]

Hallo
Bin leider mit meinem Modul auch nicht weitergekommen. Habe beim 
Hersteller angefragt. Hat sich für die Anfrage bedankt und mitgeteilt 
das alles verfügbaren Infos auf der Seite stehen. Mehr hat er nicht. 
Schade, hatte gehofft ein paar Infos oder Beispiele zu bekommen.
LG Klars

[Joe (Gast)]

Klars schrieb:
> Habe beim
> Hersteller angefragt. Hat sich für die Anfrage bedankt und mitgeteilt
> das alles verfügbaren Infos auf der Seite stehen. Mehr hat er nicht.

Was genau hast Du denn dem Hersteller geschrieben oder gefragt?

[Gert (Gast)]

Hallo,
mir geht es nicht anders. Seit einiger Zeit versuche ich auch den Sensor 
zum laufen zu bekommen. Auf Nachfragen bei Avago / Bradcom wurde auch 
nur auf die vorhandenen Dokumente verwiesen. Das besteht leider nur aus 
dem Datenblatt.
Ich benutze den Sensor als Gestensensor an einem PSOC. Der Sensor läuft 
soweit auch und generiert einen Interrupt wenn ich eine Geste ausführe. 
Wenn ich darauf hin den FIFO Speicher auslese, kommen immer die gleichen 
Werte raus, egal welche Geste ich ausführe. Das einzige was variiert ist 
die länge der Einträge im FIFO.

Gruß
Gert

[Joe (Gast)]

@Andre, Gert: Ich empfehle Dir, das Board entweder mit dem Arduino oder 
dem Raspberry Pi zu verwenden, um die Gestensteuerung zu verstehen. Du 
kannst dann ja an den entscheidenden Stellen für Dich selbst 
print-Ausgaben einfügen, um das Vorgehen des Codes/der Library besser 
nachzuvollziehen.
Es macht meiner Meinung nach keinen Sinn, die Library erst auf ein 
anderes System als Arduino bzw. Raspberry Pi zu portieren, bevor man den 
ursprünglichen Code nicht verstanden hat.

Eine Library für den Raspberry Pi gibt es hier:

https://bitbucket.org/justin_woodman/apds-9960-raspberry-pi-library/src


Gruß
Joe

[Andre (Gast)]

Hallo Joe,
 mir persönlich wäre das auch am liebsten..., aber die Vorgabe für 
dieses Projekt ist, dass ich das Kl46z Board verwende.
Leider habe ich keinen Arduino oder Rasp rumliegen.

[Joachim D. (rockjoe)]

Hallo Andre,

seit einigen Tagen habe ich nun auch von NXP das FRDM KL46Z.
Hattest Du auch unter Windows 10 damit Probleme?
Ich kann nämlich keine SDA Apps mehr auf die Bootloader Partition 
hochladen und im Kinetis Design Studio kann ich das Beispielprojekt 
"Hello World" nicht mit dem GDB PE Micro Debugger debuggen. Es erscheint 
immer wieder die Meldung "Exception occured during launch Reason: Error 
in services launch sequence".

[Buzzwang (Gast)]

Hallo,

vor Kurzem habe ich auch einen APDS-9960 in Betrieb genommen (auf einem 
ST Discovery F3 Board, ST32F303). Das Problem besteht bei mir beim 
Auswerten der Gesten-Daten. Die Flanken sind schlecht getrennt, so dass 
meine Auswertung scheitert. (Siehe Anhang). Im Vergleich zum Datenblatt 
Seite 17 kommen bei mir die Flanken nicht so schön sauber.

Hat jemand eine Idee ?
Es wäre toll, wenn hier jemand Vergleichdaten bereitstellen könnte.

Vg
  Buzzwang