Neopixel LED gyűrű vezérlése gesztusérzékelővel: 3 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:42

Ebben az oktatóanyagban egy gesztusérzékelővel (APDS-9960) és egy neopixelgyűrűvel fogunk játszani, hogy megtanuljuk, hogyan kombinálhatjuk mindkettőt egy Arduino UNO segítségével.

A végtermék a bal -jobb kézmozdulatokra reagál a LED -mozgás jobbra vagy balra, a felfelé irányuló gesztusokra pedig a LED -ek színének megváltoztatásával.

A következő lépésekben röviden áttekintheti az alkatrészlistát és az alkatrészek csatlakoztatását. Ezután lépésről lépésre áttekintjük a kódot, hogy megtudjuk, hogyan működik.

1. lépés: Alkatrészek

1. Arduino UNO

2. usb kábel

3. APDS9960 gesztusérzékelő (https://www.sparkfun.com/products/12787)

4. 24 ledes neopixel led gyűrű (https://www.adafruit.com/product/1586)

5. férfi-nő, férfi-férfi kenyérlap kábelek

6. kenyeretábla

7. 5 V -os tápegység a led gyűrűhöz (4 elemes hátlapot használok)

8. A neopixelgyűrűnek a kenyérlaphoz való rögzítéséhez három hüvelyes tűt kell forrasztani: GND, PWR és vezérlőtű. Ehhez forrasztópáka és fluxus szükséges

A fő összetevők itt az APDS-9960 gesztusérzékelő és a 24 neopixel gyűrű. Igény szerint válthat különböző arduinókról, USB -kábelekről és tápegységekről.

2. lépés: Összeszerelés és feltöltés

Összeszerelés

Mielőtt elkezdené, győződjön meg róla, hogy az összes összetevő az asztalon van. Követni fogunk néhány szép lépést:). A Fritzing sematikáját is csatoltam képként és fritzing formátumban is.

1. Forrasztjon 3 dugót a neopixelgyűrűhöz (GND, PWR, vezérlőcsap)

2. rögzítse a neopixel gyűrűt a kenyértáblához

3. Csatlakoztassa az APDS9960 érzékelőt a kenyértáblához

4. Csatlakoztassa az alapokat: akkumulátor, Arduino UNO, APDS9960 és neopixel a kenyérlaphoz

5. csatlakoztassa a tápellátást: arduino UNO 3V az APDS9960 tápcsatlakozóhoz, a neopixelt az akkumulátorhoz

6. csatlakoztassa a neopixel vezérlőcsapot az arduino D6 tűhöz

7. csatlakoztassa az APDS9960 SDA -ját és SCL -jét az A4 -es, illetve az A5 -öshöz

8. csatlakoztassa az APDS9960 megszakító tüskét az arduino D2 -hez

Kód feltöltése

Először is le kell töltenie és telepítenie kell a szükséges arduino könyvtárakat:

1. Neopixel gyűrűs könyvtár:

2. Gesztusérzékelő könyvtár:

Ha nem tudja, hogyan kell telepíteni az arduino könyvtárakat, nézze meg ezt az oktatóanyagot.

Miután letöltötte és telepítette a fenti könyvtárakat, klónozhatja vagy letöltheti az itt található arduino táromat: https://github.com/danionescu0/arduino, és ezt a vázlatot használjuk: https://github.com/danionescu0 /arduino/tree/master/projektek/neopixel_ring_gestures

A következő részben beágyazom a kódot közvetlenül ebbe az oktatóanyagba, így ha úgy tetszik, másolja ki és illessze be onnan.

Végül csatlakoztassa az arduino -t a számítógéphez az USB -kábellel, tegyen 1,5 V -os elemeket az akkumulátorba, és töltse fel a vázlatot az arduino -ba.

3. lépés: Hogyan működik?

Ebben az utolsó részben megtanuljuk, hogyan kombinálják ezeket az összetevőket, hogyan használják a könyvtáraikat, és hogyan strukturáltam a kódomat:

Először vessünk egy gyors pillantást az érzékelőre és az általunk használt neopixel könyvtár API módszerekre

1. Neopixel API adafruitból

Ebből a könyvtárból azokat a módszereket fogjuk használni, amelyek vezérlik az egyes LED -ek színét és alkalmazzák azokat

- tartalmazza a könyvtárat:

#befoglalni

- nyilatkozzon a könyvtár

#define NEOPIXED_CONTROL_PIN 6

#define NUM_LEDS 24 Adafruit_NeoPixel strip = Adafruit_NeoPixel (NUM_LEDS, NEOPIXED_CONTROL_PIN, NEO_RBG + NEO_KHZ800);

- inicializálni

#tipikusan a beállítási blokkon belül

void setup () {strip.begin (); # talán van itt még valami más is…. }

- világítsa meg az egyes képpontokat, majd alkalmazza az összes módosítást a szalagon (bizonyos módon)

# állítsa be a 0 pixelt vörösre

strip.setPixelColor (0, strip. Color (255, 0, 0)); # állítsa be az 1. pixelt zöld csíknak.setPixelColor (1, strip. Color (0, 255, 0)); # állítsa be a 2. képpontot kék csíknak. setPixelColor (2, strip. Color (0, 0 255)); strip.show ();

2. APDS 9960 gesztusérzékelő

Ebből a könyvtárból az "olvasási gesztus" funkciót fogjuk használni. Ez a funkció képes lesz megkülönböztetni a bal-jobb, fel-le, közel-távol parancsokat. Van itt egy trükk, nem fogjuk folyamatosan kérni az érzékelőt az utolsó érzékelt gesztustól. A tábla képes arra, hogy "pingáljon" egy megszakításon keresztül, amely gesztust talált.

- tartalmazza a könyvtárat, hasonlóan a neopixelhez

- nyilvánítsuk a könyvtárat a megszakító csapnak és a megszakítás jelzőnek

#define APDS9960_INT 2

SparkFun_APDS9960 apds = SparkFun_APDS9960 (); int isr_flag = 0;

- inicializálja a könyvtárat, általában a beállítási funkción belül

üres beállítás ()

{ # deklarálja a megszakító csapot INPUT -nak, és csatoljon hozzá egy függvényt pinMode (APDS9960_INT, INPUT); attachInterrupt (0, interruptRutin, FALLING); if (apds.init () && apds.enableGestureSensor (true)) {Serial.println ("APDS-9960 inicializálás kész"); } else {Serial.println ("Valami hiba történt az APDS-9960 init alatt!"); } # más dolgok inicializálása talán}

- határozza meg a megszakítás funkciót, itt csak egy zászlót állítunk be

void interruptRutin () {

isr_zászló = 1; }

- a ciklus funkcióban rendszeresen ellenőrizze a zászlót, hogy nem észlelt -e gesztust

üres hurok ()

{ # ellenőrizze a zászlót, ha (isr_flag == 1) { # ha a zászló be van állítva, távolítsa el a megszakítást, végezze el a szükséges feldolgozást a handleGesture () függvény # belsejében, majd állítsa vissza a zászlót, és csatlakoztassa újra a megszakítás detachInterrupt (0); handleGesture (); isr_flag = 0; attachInterrupt (0, interruptRutin, FALLING); } # valami más kód talán itt}

- define handleGesture () függvény, ahol kérhetjük az utolsó gesztust

void handleGesture () {

# ha nem elérhető gesztus, akkor ez csak biztonságos ellenőrzés, ha (! apds.isGestureAvailable ()) {return; } # elolvassa az utolsó gesztust, összehasonlítja az ismertekkel, és kinyomtat egy üzenetváltót (apds.readGesture ()) {case DIR_UP: Serial.println ("UP"); szünet; eset DIR_DOWN: Serial.println ("LE"); szünet; case DIR_LEFT: Serial.println ("LEFT"); szünet; eset DIR_RIGHT: Serial.println ("RIGHT"); szünet; eset DIR_FAR: Serial.println ("FAR"); szünet; }}

Most nézzük a teljes kódot működés közben:

Tehát elmagyaráztam a gesztusérzékelő és a neopixelgyűrű alap API -ját, most tegyük össze a dolgokat:

Az algoritmus a következőképpen fut:

- inicializálja a könyvtárakat (lásd a fenti kódot)

- hozzon létre egy sor led intenzitást, amelyet "ledStates" -nek neveznek. Ez a tömb 24 led intenzitást tartalmaz, amelyek csökkenő módon vannak elrendezve 150 -ről 2 -re

- a főhurok belsejében ellenőrizze, hogy a megszakító csap módosult -e, ha igen, ideje megváltoztatni a LED animációját vagy színét

- a "handleGesture ()" függvény ellenőrzi az utolsó gesztust, és meghívja a "toggleColor" függvényt a FEL -LE mozdulatokhoz, vagy beállítja a "ledDirection" globális változót a BAL -JOBB gesztusokhoz

- a "toggleColor ()" függvény egyszerűen megváltoztatja a "colorSelection" nevű globális változót a 0, 1, 2 értékek egyikével

- a fő hurokfüggvényen belül egy másik "animateLeds ()" nevű függvény is; nak, nek hívják. Ez a funkció ellenőrzi, hogy 100 milliszekundum eltelt -e, és ha igen, akkor forgatja a LED -eket a "rotateLeds ()" függvénnyel, majd újrarajzolja őket

- A "rotateLeds ()" "elforgatja" a ledeket előre vagy hátra egy másik "intermediateLedStates" nevű tömb használatával.

A forgatás "hatása" így néz ki:

# az inicializálás után

{150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # A rotateLeds () után {0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # a rotateLeds () után ismét meghívásra kerül {0, 0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # stb

Ehhez először létrehozza az új tömböt, és lemásolja a régi led intenzitásokat az új pozíciókra (növelje vagy csökkentse). Ezt követően felülírja a "ledStates" tömböt az "intermediateLedStates" -al, így a folyamat további 100 ezredmásodperc múlva folytatódik.

#include "SparkFun_APDS9960.h"

#include "Adafruit_NeoPixel.h"

#include "Wire.h" #define NEOPIXED_CONTROL_PIN 6 #define NUM_LEDS 24 #define APDS9960_INT 2 #define LED_SPEED_STEP_INTERVAL 100 Adafruit_NeoPixel strip = Adafruit_NeoPixel (NUM_LEDS, NEOX; NEOPIX SparkFun_APDS9960 apds = SparkFun_APDS9960 (); unsigned long lastLedChangeTime = 0; rövid ledDirection = 0; rövid színválasztás = 0; byte ledStates = {150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; int isr_flag = 0; void setup () {Serial.begin (9600); Serial.println ("A program elindult"); strip.begin (); pinMode (APDS9960_INT, INPUT); attachInterrupt (0, interruptRutin, FALLING); if (apds.init () && apds.enableGestureSensor (true)) {Serial.println ("APDS-9960 inicializálás kész"); } else {Serial.println ("Valami hiba történt az APDS-9960 init alatt!"); } lastLedChangeTime = millis (); Serial.println ("Init sikeres"); } void loop () {if (isr_flag == 1) {detachInterrupt (0); handleGesture (); isr_flag = 0; attachInterrupt (0, interruptRutin, FALLING); } animateLeds (); } void interruptRutin () {isr_flag = 1; } / ** * Ez az APDS9960 érzékelő gesztusait fogja kezelni; } switch (apds.readGesture ()) {case DIR_UP: Serial.println ("UP"); toggleColor (); szünet; eset DIR_DOWN: Serial.println ("LE"); toggleColor (); szünet; DIR_LEFT eset: ledDirection = 1; Serial.println ("LEFT"); szünet; eset DIR_RIGHT: ledDirection = -1; Serial.println ("RIGHT"); szünet; DIR_FAR eset: ledDirection = 0; Serial.println ("FAR"); szünet; }} / ** * Az aktuális LED -ek színének módosítása * Minden alkalommal, amikor ezt a funkciót meghívják, megváltozik a ledek állapota * / void toggleColor () {if (colorSelection == 0) {colorSelection = 1; } else if (színválasztás == 1) {színválasztás = 2; } else {colorSelection = 0; }} / ** * Az animáció a LED_SPEED_STEP_INTERVAL millis után fog futni; } rotateLeds (); for (int i = 0; i <NUM_LEDS; i ++) {strip.setPixelColor (i, getColor (ledStates ))); strip.show (); } lastLedChangeTime = millis (); } /** * Másodlagos "intermediateLedStates" tömb használatával a LED -ek intenzitása animált lesz., 0, 0} és a ledDirection 1 *, majd miután ezt a függvényt "ledStates" -nek nevezzük, a tömb {0, 100, 80, 60, 0, 0} szimulálja a forgáshatást */ void rotateLeds () {bájt intermediateLedStates [NUM_LEDS]; for (int i = 0; i <NUM_LEDS; i ++) {intermediateLedStates = 0; } for (int i = 0; i <NUM_LEDS; i ++) {if (ledDirection == 1) {if (i == NUM_LEDS -1) {intermediateLedStates [0] = ledStates ; } else {intermediateLedStates [i + 1] = ledStates ; }} else {if (i == 0) {intermediateLedStates [NUM_LEDS - 1] = ledStates ; } else {intermediateLedStates [i - 1] = ledStates ; }}} for (int i = 0; i <NUM_LEDS; i ++) {ledStates = intermediateLedStates ; }} uint32_t getColor (int intenzitás) {switch (colorSelection) {case 0: return strip. Color (intenzitás, 0, 0); 1. eset: visszatérő csík. Szín (0, intenzitás, 0); alapértelmezett: visszatérési csík. Szín (0, 0, intenzitás); }}

Remélem tetszett ez, a megjegyzések részben kérdezhet.