Die beheer van 'n Neopixel Led -ring met 'n gebaar sensor: 3 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:26

In hierdie tutoriaal gaan ons speel met 'n gebaarsensor (APDS-9960) en 'n neopixelring om te leer hoe om albei met 'n Arduino UNO te kombineer.

Die eindproduk reageer op links - regs gebare deur geleide beweging na regs of links te animeer, en na opwaartse gebare deur die kleur van LED's te verander.

In die volgende stappe gee u 'n kort oorsig van die onderdelelys en hoe u die komponente kan koppel. En dan hersien ons die kode stap vir stap om te leer hoe dit werk.

Stap 1: Komponente

1. Arduino UNO

2. usb -kabel

3. APDS9960 gebaar sensor (https://www.sparkfun.com/products/12787)

4. 24 led neopixel led ring (https://www.adafruit.com/product/1586)

5. mannetjie-wyfie, man-man-broodbordkabels

6. broodbord

7. 5 V kragtoevoer vir die led ring (ek gebruik 'n 4 battery agterkant)

8. Om die neopixelring aan die broodbord te heg, moet u drie mannetjiespenne daaraan soldeer: GND, PWR en bedieningspen. Hiervoor benodig u 'n soldeerbout en vloeistof

Die belangrikste komponente hier is APDS-9960 gebaar sensor en die 24 neopixel ring. U kan verskillende arduino's, USB -kragtoevoer en broodborde verander soos u wil.

Stap 2: Vergadering en oplaai

Vergadering

Maak seker dat u al die komponente op u tafel het voordat u begin. Ons sal 'n paar goeie stappe volg:). Ek het ook die Fritzing -skematika as 'n prentjie aangeheg en ook in fritz -formaat.

1. Soldeer 3 mannetjiespenne aan die neopixelring (GND, PWR, bedieningspen)

2. bevestig die neopixelring aan die broodbord

3. Bevestig die APDS9960 -sensor aan die broodbord

4. verbind die gronde: battery pack, arduino UNO, APDS9960 en neopixel met die broodbordgrond

5. koppel die krag: arduino UNO 3V aan die APDS9960 -kragpen, neopixel na die battery

6. koppel die neopixel -bedieningspen aan die arduino D6 -pen

7. koppel SDA en SCL van die APDS9960 aan onderskeidelik die A4 en A5

8. koppel die APDS9960 -onderbrekingspen aan die arduino D2

Kode oplaai

Eerstens moet u die nodige arduino -biblioteke aflaai en installeer:

1. Neopixel -ringbiblioteek:

2. Gebaar sensor biblioteek:

As u nie weet hoe om arduino -biblioteke te installeer nie, kyk dan na hierdie handleiding.

Nadat u die bogenoemde biblioteke afgelaai en geïnstalleer het, kan u my arduino -bewaarplek hier aflaai: https://github.com/danionescu0/arduino, en ons sal hierdie skets gebruik: https://github.com/danionescu0 /arduino/tree/master/projects/neopixel_ring_gestures

In die volgende afdeling sal ek die kode direk in hierdie tutoriaal insluit, so as u wil, kan u dit van daar af kopieer en plak.

Sluit laastens die arduino aan op die rekenaar met die usb -kabel, steek 1,5 volt batterye in die battery en laai die skets op in die arduino.

Stap 3: Hoe werk dit?

In hierdie laaste deel leer ons hoe hierdie komponente saamgevoeg word, hoe om hul biblioteke te gebruik en hoe ek my kode saamgestel het:

Laat ons eers vinnig kyk na die sensor en die API -metodes van die neopixelbiblioteek wat ons sal gebruik

1. Neopixel API van adafruit

Uit hierdie biblioteek gebruik ons die metodes wat die kleur van die individuele LED beheer en dit toepas

- sluit die biblioteek in:

#insluit

- verklaar die biblioteek

#definieer NEOPIXED_CONTROL_PIN 6

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

- inisialiseer

#tipies binne die opstelblok

ongeldige opstelling () {strip.begin (); # miskien 'n paar ander goed hier # … }

- Verlig individuele pixels en pas dan alle wysigings op die strook toe (gee dit op 'n manier weer)

# stel pixel 0 op om rooi te wees

strip.setPixelColor (0, strip. Color (255, 0, 0)); # stel pixel 1 op as groen strip.setPixelColor (1, strip. Color (0, 255, 0)); # stel pixel 2 op as blou strip.setPixelColor (2, strip. Color (0, 0 255)); strip.show ();

2. APDS 9960 gebaar sensor

Vanuit hierdie biblioteek gebruik ons die 'leesgebaar' -funksie. Hierdie funksie sal kan onderskei tussen links-regs, op-af, naby-opdragte. Hier is 'n truuk; ons gaan die sensor nie voortdurend vra vir die laaste gebaar wat waargeneem word nie. Die bord het die vermoë om deur 'n onderbreking te "ping" dat 'n gebaar gevind is.

- sluit die biblioteek in, soortgelyk aan die neopixel

- verklaar die biblioteek as die onderbrekingspen en die onderbrekingsvlag

#definieer APDS9960_INT 2

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

- initialiseer die biblioteek, gewoonlik binne die opstelfunksie

leemte opstelling ()

{ # verklaar die onderbrekingspen as INVOER en heg 'n funksie daaraan pinMode (APDS9960_INT, INPUT); attachInterrupt (0, interruptRoutine, FALLING); if (apds.init () && apds.enableGestureSensor (true)) {Serial.println ("APDS-9960 inisialisering voltooi"); } anders {Serial.println ("Iets het skeefgeloop tydens APDS-9960 init!"); } # begin ander dinge miskien}

- definieer die onderbrekingsfunksie, hier stel ons slegs 'n vlag in

leegte interruptRoutine () {

isr_flag = 1; }

- binne -in die lusfunksie, kyk gereeld na die vlag om te sien of 'n gebaar opgespoor is

leemte lus ()

{ # kyk na die vlag as (isr_flag == 1) { # as die vlag gestel is, verwyder die onderbreking, voer die nodige verwerking binne handleGesture () -funksie uit # en stel dan die vlag terug en koppel die onderbreking detachInterrupt (0) weer aan; handleGesture (); isr_flag = 0; attachInterrupt (0, interruptRoutine, FALLING); } # dalk 'n ander kode hier}

- definieer handleGesture () -funksie waar ons die laaste gebaar kan vra

leeg handvatselGesture () {

# as geen gebaar beskikbaar is nie, is dit slegs 'n veilige tjek of (! apds.isGestureAvailable ()) {return; } # lees die laaste gebaar, vergelyk met die bekendes en druk 'n boodskapskakelaar uit (apds.readGesture ()) {case DIR_UP: Serial.println ("UP"); breek; saak DIR_DOWN: Serial.println ("DOWN"); breek; saak DIR_LEFT: Serial.println ("LEFT"); breek; saak DIR_RIGHT: Serial.println ("REGS"); breek; saak DIR_FAR: Serial.println ("FAR"); breek; }}

Laat ons nou die hele kode in aksie sien:

Dus het ek die basiese API van die gebaar sensor en die neopixel ring verduidelik, laat ons nou dinge saamstel:

Die algoritme loop soos volg:

- initialiseer die biblioteke (sien die kode hierbo)

- skep 'n verskeidenheid LED -intensiteite genaamd "ledStates". Hierdie skikking sal 24 LED -intensiteite bevat wat op 'n dalende manier van 150 tot 2 gerangskik is

- kyk binne die hooflus of die onderbrekingspen verander is, indien wel, is dit tyd om die animasie of kleur van LED te verander

- die funksie "handleGesture ()" kontroleer die laaste gebaar en noem die funksie "toggleColor" vir UP -DOWN gebare of stel 'n globale veranderlike "ledDirection" in vir LINKS - REGS gebare

- die funksie "toggleColor ()" verander eenvoudig 'n globale veranderlike met die naam "colorSelection" met een van die waardes 0, 1, 2

- ook binne die hooflusfunksie 'n ander funksie met die naam "animateLeds ();" is genoem. Hierdie funksie kontroleer of 100 millisekondes verby is, en indien wel, draai dit die LED's met die funksie "rotateLeds ()" en teken dit dan weer oor

- die "rotateLeds ()" sal die leds vorentoe of agtertoe "draai" deur 'n ander skikking genaamd "intermediateLedStates" te gebruik.

Die rotasie -effek sal so lyk:

# na inisialisering

{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}; # after rotateLeds () word {0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # after rotateLeds () word weer genoem {0, 0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # en so aan

Hiervoor skep u eers die nuwe skikking en kopieer u die ou led -intensiteite op die nuwe posisies (verhoog die posisie of verminder dit). Daarna oorskryf dit die "ledStates" -skikking met die "intermediateLedStates", sodat die proses na nog 100 millisekondes sal voortgaan.

#sluit "SparkFun_APDS9960.h" in

#sluit "Adafruit_NeoPixel.h" in

#insluit "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 (NE_LOOD_, NEOPIX_, NEOPIX_ SparkFun_APDS9960 apds = SparkFun_APDS9960 (); ongetekende lang lastLedChangeTime = 0; kort ledDirection = 0; kort colorSelection = 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}; int isr_flag = 0; ongeldige opstelling () {Serial.begin (9600); Serial.println ("Program begin"); strip.begin (); pinMode (APDS9960_INT, INPUT); attachInterrupt (0, interruptRoutine, FALLING); if (apds.init () && apds.enableGestureSensor (true)) {Serial.println ("APDS-9960 inisialisering voltooi"); } anders {Serial.println ("Iets het skeefgeloop tydens APDS-9960 init!"); } lastLedChangeTime = millis (); Serial.println ("Init suksesvol"); } leemte -lus () {if (isr_flag == 1) {detachInterrupt (0); handleGesture (); isr_flag = 0; attachInterrupt (0, interruptRoutine, FALLING); } animateLeds (); } leegte interruptRoutine () {isr_flag = 1; } / ** * Dit sal gebare van die APDS9960 -sensor af hanteer * Op en af -gebare sal toggle roep Kleurfunksie * Links en regs gebare verander die LED -animasie * / void handleGesture () {if (! Apds.isGestureAvailable ()) {return; } skakelaar (apds.readGesture ()) {saak DIR_UP: Serial.println ("UP"); toggleColor (); breek; saak DIR_DOWN: Serial.println ("DOWN"); toggleColor (); breek; saak DIR_LEFT: ledDirection = 1; Serial.println ("LINKS"); breek; saak DIR_RIGHT: ledDirection = -1; Serial.println ("REGS"); breek; saak DIR_FAR: ledDirection = 0; Serial.println ("FAR"); breek; }} / ** * Verander die huidige LED -kleur * Elke keer as hierdie funksie genoem word, verander die LED -toestand * / void toggleColor () {if (colorSelection == 0) {colorSelection = 1; } anders as (colorSelection == 1) {colorSelection = 2; } anders {colorSelection = 0; }} / ** * Die animasie word uitgevoer na LED_SPEED_STEP_INTERVAL millis * Eers word die rotateLeds -funksie genoem, dan word die leds se kleure ingestel met behulp van die strook api * / void animateLeds () {if (millis () - lastLedChangeTime <LED_SPEED_STEP_INTERVAL) {return; } rotateLeds (); for (int i = 0; i <NUM_LEDS; i ++) {strip.setPixelColor (i, getColor (ledStates ))); strip.show (); } lastLedChangeTime = millis (); } /** * Deur 'n sekondêre skikking "intermediateLedStates" te gebruik, word LED -intensiteite geanimeer * Eerstens word die waardes van "ledStates" op "intermediateLedStates" gekopieer soos so * laat ons die "ledStates" skikking is {100, 80, 60, 0, 0, 0} en die ledDirection is 1 * en nadat hierdie funksie "ledStates" genoem word, word die skikking {0, 100, 80, 60, 0, 0} 'n rotasie -effek */ leegte rotateLeds () {byte intermediateLedStates [NUM_LEDS gesimuleer]; vir (int i = 0; i <NUM_LEDS; i ++) {intermediateLedStates = 0; } vir (int i = 0; i <NUM_LEDS; i ++) {if (ledDirection == 1) {if (i == NUM_LEDS -1) {intermediateLedStates [0] = ledStates ; } anders {intermediateLedStates [i + 1] = ledStates ; }} anders {if (i == 0) {intermediateLedStates [NUM_LEDS - 1] = ledStates ; } anders {intermediateLedStates [i - 1] = ledStates ; }}} vir (int i = 0; i <NUM_LEDS; i ++) {ledStates = intermediateLedStates ; }} uint32_t getColor (int intensiteit) {switch (colorSelection) {case 0: return strip. Color (intensiteit, 0, 0); geval 1: retourstrook. Kleur (0, intensiteit, 0); standaard: retourstrook. Kleur (0, 0, intensiteit); }}

Ek hoop dat u dit geniet het; u kan die kommentaarafdeling gebruik om vrae aan my te stel.