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.
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:
1 | uint8_t read_APDS9960(uint8_t reg) |
2 | {
|
3 | //uart_puts("In function read_APDS9960.\n");
|
4 | uint8_t reg_value = 0; |
5 | |
6 | char buffer[10]; |
7 | |
8 | uint8_t twst_start; //flag to check whether the START condition has been transmitted successfully |
9 | uint8_t twst_start_2; //flag to check whether the second START condition has been transmitted successfully |
10 | uint8_t twst_sla_addr; //flag to check whether the slave device plus W-Bit has been transmitted successfully |
11 | uint8_t twst_sla_addr_2; //flag to check whether slave address plus R-Bit has been transmitted successfully |
12 | uint8_t twst_reg_addr; //flag to check whether the register address of slave could be addressed successfully |
13 | uint8_t twst_ma_answer; //flag to check the master's response: ACK or NACK |
14 | |
15 | //////////---Begin of Read Protocol Combined Format---//////////
|
16 | |
17 | //---send START condition----------------------------//
|
18 | //uart_puts("Sending START condition...\n");
|
19 | TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTA); |
20 | while(!(TWCR & (1<<TWINT))); |
21 | twst_start = TW_STATUS; |
22 | if(twst_start != TW_START) |
23 | {
|
24 | uart_puts("Failed to send START...\n"); |
25 | TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO); |
26 | while((TWCR & (1<<TWSTO))); |
27 | return false; |
28 | }
|
29 | |
30 | |
31 | //---send slave's address plus R/W Bit---------------//
|
32 | //uart_puts("Sending SLA+W...\n");
|
33 | TWDR = ((APDS9960_I2C_ADDR<<1) | TW_WRITE); |
34 | TWCR = (1<<TWEN) | (1<<TWINT); |
35 | while(!(TWCR & (1<<TWINT))); |
36 | twst_sla_addr = TW_STATUS; |
37 | if(twst_sla_addr != TW_MT_SLA_ACK) |
38 | {
|
39 | uart_puts("Failed to send SLA+W...\n"); |
40 | TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO); |
41 | while((TWCR & (1<<TWSTO))); |
42 | return false; |
43 | }
|
44 | |
45 | |
46 | //---send address of the register to read from--------//
|
47 | //uart_puts("Sending register address...\n");
|
48 | TWDR = reg; |
49 | TWCR = (1<<TWEN) | (1<<TWINT); |
50 | while(!(TWCR & (1<<TWINT))); |
51 | twst_reg_addr = TW_STATUS; |
52 | if(twst_reg_addr != TW_MT_DATA_ACK) |
53 | {
|
54 | uart_puts("Failed to send register address...\n"); |
55 | TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO); |
56 | while((TWCR & (1<<TWSTO))); |
57 | return false; |
58 | }
|
59 | |
60 | |
61 | //---send START condition----------------------------//
|
62 | //uart_puts("Sending REPEATED START condition...\n");
|
63 | TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTA); |
64 | while(!(TWCR & (1<<TWINT))); |
65 | twst_start_2 = TW_STATUS; |
66 | if(twst_start_2 != TW_REP_START) |
67 | {
|
68 | uart_puts("Failed to send REPEATED START...\n"); |
69 | TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO); |
70 | while((TWCR & (1<<TWSTO))); |
71 | return false; |
72 | }
|
73 | |
74 | |
75 | //---send slave's address plus R/W Bit---------------//
|
76 | //uart_puts("Sending SLA+R...\n");
|
77 | TWDR = ((APDS9960_I2C_ADDR<<1) | TW_READ); |
78 | TWCR = (1<<TWEN) | (1<<TWINT); |
79 | while(!(TWCR & (1<<TWINT))); |
80 | twst_sla_addr_2 = TW_STATUS; |
81 | if(twst_sla_addr_2 != TW_MR_SLA_ACK) |
82 | {
|
83 | uart_puts("Failed to send SLA+R...\n"); |
84 | utoa(twst_sla_addr_2, buffer, 16); |
85 | uart_puts("0x"); |
86 | uart_puts(buffer); |
87 | uart_puts("\n"); |
88 | TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO); |
89 | while((TWCR & (1<<TWSTO))); |
90 | |
91 | return false; |
92 | }
|
93 | |
94 | |
95 | //---receive data from the previous addressed register and return NACK----//
|
96 | //uart_puts("Receiving data from slave...\n");
|
97 | TWCR = (1<<TWEN) | (1<<TWINT); |
98 | while(!(TWCR & (1<<TWINT))); |
99 | _delay_ms(100); |
100 | reg_value = TWDR; |
101 | twst_ma_answer = TW_STATUS; |
102 | if(twst_ma_answer != TW_MR_DATA_NACK) |
103 | {
|
104 | TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO); |
105 | while((TWCR & (1<<TWSTO))); |
106 | return false; |
107 | }
|
108 | |
109 | |
110 | //---send a STOP condition---------------------------//
|
111 | TWCR = (1<<TWEN) | (1<<TWINT) | (1<<TWSTO); |
112 | while((TWCR & (1<<TWSTO))); |
113 | |
114 | //////////---End of Read Protocol Combined Format---//////////
|
115 | |
116 | |
117 | |
118 | //--print TWI status reports to screen
|
119 | |
120 | uart_puts("Printing TWI status flags of Read Protocol Combined Format...\n"); |
121 | |
122 | utoa(twst_start, buffer, 16); |
123 | uart_puts("0x"); |
124 | uart_puts(buffer); |
125 | uart_puts("\n"); |
126 | |
127 | utoa(twst_sla_addr, buffer, 16); |
128 | uart_puts("0x"); |
129 | uart_puts(buffer); |
130 | uart_puts("\n"); |
131 | |
132 | utoa(twst_reg_addr, buffer, 16); |
133 | uart_puts("0x"); |
134 | uart_puts(buffer); |
135 | uart_puts("\n"); |
136 | |
137 | utoa(twst_start_2, buffer, 16); |
138 | uart_puts("0x"); |
139 | uart_puts(buffer); |
140 | uart_puts("\n"); |
141 | |
142 | utoa(twst_sla_addr_2, buffer, 16); |
143 | uart_puts("0x"); |
144 | uart_puts(buffer); |
145 | uart_puts("\n"); |
146 | |
147 | utoa(twst_ma_answer, buffer, 16); |
148 | uart_puts("0x"); |
149 | uart_puts(buffer); |
150 | uart_puts("\n"); |
151 | uart_puts("\n"); |
152 | |
153 | return reg_value; |
154 | }
|
Ich weiß echt nicht mehr weiter...
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.
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.
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
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.
Bin am staunen was du so alles hast. Kannst du die Software weiterleiten?
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
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
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ß
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
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
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
@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.
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.
Hallo zusammen, ich stehen auch vor dem Problem, dass ich die Gestensteuerung nicht zum Laufen bekomme. Hat irgendjemand eine Lösung?
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...?
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
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
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?
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
@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
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.
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".
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
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.