Kontrolli i një unaze të udhëhequr nga Neopixel me një sensor gjestesh: 3 hapa (me fotografi)

2024 Autor: John Day | [email protected]. E modifikuara e fundit: 2024-01-30 12:21

Në këtë tutorial ne do të luajmë me një sensor gjestesh (APDS-9960) dhe një unazë neopixel për të mësuar se si t'i kombinojmë të dy duke përdorur një Arduino UNO.

Produkti përfundimtar do t'i përgjigjet gjesteve majtas - djathtas duke animuar lëvizjen e drejtuar djathtas ose majtas, dhe gjestet lart -poshtë duke ndryshuar ngjyrën e leds.

Në hapat e ardhshëm, do të shikoni shkurtimisht listën e pjesëve dhe mënyrën e lidhjes së përbërësve. Dhe pastaj ne do të rishikojmë kodin hap pas hapi për të mësuar se si funksionon.

Hapi 1: Përbërësit

1. Arduino UNO

2. kabllo usb

3. Sensori i gjesteve APDS9960 (https://www.sparkfun.com/products/12787)

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

5. kabllot e bukës mashkull-femër, mashkull-mashkull

6. dërrasë buke

7. Furnizimi me energji 5 V për unazën led (unë jam duke përdorur një bateri 4 mbrapa)

8. Për të bashkuar unazën neopixel në dërrasën e bukës do t'ju duhet të lidhni tre kunja meshkuj në të: GND, PWR dhe kunj kontrolli. Për këtë do t'ju duhet një hekur bashkues dhe fluks

Komponentët kryesorë këtu janë sensori i gjesteve APDS-9960 dhe unaza 24 neopixel. Ju mund të ndërroni arduino të ndryshëm, kabllo usb furnizim me energji dhe tabela buke sipas dëshirës tuaj.

Hapi 2: Montimi dhe Ngarkimi

Kuvendi

Para se të filloni, sigurohuni që të keni të gjithë përbërësit në tryezën tuaj. Do të kemi disa hapa të bukur për të ndjekur:). Unë e kam bashkangjitur edhe skemën Fritzing si një fotografi dhe gjithashtu në format fritzing.

1. Bashkoni 3 kunja meshkuj në unazën neopixel (GND, PWR, kunja e kontrollit)

2. lidhni unazën neopixel në dërrasën e bukës

3. bashkëngjitni sensorin APDS9960 në tabelën e bukës

4. lidhni bazat: paketën e baterisë, arduino UNO, APDS9960 dhe neopixel në tokën e bukës

5. lidhni fuqinë: arduino UNO 3V me pinin e energjisë APDS9960, neopixel me fuqinë e paketës së baterisë

6. lidhni pinin e kontrollit neopixel me pinin arduino D6

7. lidhni SDA dhe SCL të APDS9960 me A4 dhe A5 respektivisht

8. lidhni pinin e ndërprerjes APDS9960 me arduino D2

Ngarkimi i kodit

Para së gjithash do t'ju duhet të shkarkoni dhe instaloni bibliotekat e nevojshme arduino:

1. Biblioteka unazore neopixel:

2. Biblioteka e sensorit të gjesteve:

Nëse nuk dini si të instaloni bibliotekat arduino shikoni këtë tutorial.

Pasi të keni shkarkuar dhe instaluar bibliotekat e mësipërme, mund të klononi ose shkarkoni depon time arduino të vendosur këtu: https://github.com/danionescu0/arduino, dhe ne do ta përdorim këtë skicë: https://github.com/danionescu0 /arduino/tree/master/projects/neopixel_ring_gestures

Në seksionin tjetër unë do ta fut kodin direkt në këtë tutorial, kështu që nëse ju pëlqen mund ta kopjoni dhe ngjisni nga atje.

Më në fund lidhni kompjuterin arduino duke përdorur kabllon usb, vendosni bateri 1.5 v në paketë baterie dhe ngarkoni skicën në arduino.

Hapi 3: Si funksionon?

Në këtë pjesë të fundit do të mësojmë se si kombinohen këto përbërës së bashku, si të përdorin bibliotekat e tyre dhe si e kam strukturuar kodin tim:

Së pari le të hedhim një vështrim të shpejtë përmes sensorit dhe metodave API të bibliotekës neopixel që do të përdorim

1. Neopixel API nga adafruit

Nga kjo bibliotekë ne do të përdorim metodat që kontrollojnë ngjyrën e led -it individual dhe i zbatojmë ato

- përfshini bibliotekën:

#përfshi

- deklarojnë bibliotekën

#përcakto NEOPIXED_CONTROL_PIN 6

#përcakto NUM_LEDS 24 Shirit Adafruit_NeoPixel = Adafruit_NeoPixel (NUM_LEDS, NEOPIXED_CONTROL_PIN, NEO_RBG + NEO_KHZ800);

- inicoj

#tipikisht brenda bllokut të konfigurimit

void setup () {strip.begin (); # ndoshta disa gjëra të tjera këtu #…. }

- ndizni pixel -et individualë dhe më pas aplikoni të gjitha modifikimet në shirit (jepeni në një mënyrë)

# vendos pixel 0 që të jetë i kuq

strip.setPixelColor (0, strip. Color (255, 0, 0)); # vendosni pikselin 1 të jetë shirit i gjelbër. setPixelColor (1, shirit. Ngjyra (0, 255, 0)); # vendos pixel 2 të jetë blu strip.setPixelColor (2, strip. Color (0, 0 255)); shirit.shfaq ();

2. Sensori i gjesteve APDS 9960

Nga kjo bibliotekë ne do të përdorim funksionin "lexo gjestin". Ky funksion do të jetë në gjendje të bëjë dallimin midis komandave majtas-djathtas, lart-poshtë, afër-larg. Ekziston një truk këtu, ne nuk do të kërkojmë nga sensori vazhdimisht gjestin e fundit të perceptuar. Bordi ka aftësinë për të "ping" përmes një ndërprerjeje që është gjetur një gjest.

- përfshini bibliotekën, e ngjashme me neopixelin

- shpallni bibliotekën pinin e ndërprerjes dhe flamurin e ndërprerjes

#përcaktoni APDS9960_INT 2

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

- iniconi bibliotekën, zakonisht brenda funksionit të konfigurimit

void setup ()

{ # deklaro pinin e ndërprerjes si INPUT dhe bashkoji një funksion pinMode (APDS9960_INT, INPUT); attachInterrupt (0, interruptRutine, FALLING); if (apds.init () && apds.enableGestureSensor (e vërtetë)) {Serial.println ("Fillimi i APDS-9960 i plotë"); } else {Serial.println ("Diçka shkoi keq gjatë APDS-9960 init!"); } # filloni ndoshta gjëra të tjera}

- përcaktoni funksionin e ndërprerjes, këtu do të vendosim vetëm një flamur

void interruptRoutine () {

isr_flag = 1; }

- brenda funksionit të lakut kontrolloni periodikisht flamurin për të parë nëse një gjest është zbuluar

lak void ()

{ # kontrolloni flamurin nëse (isr_flag == 1) { # nëse flamuri është vendosur, hiqni ndërprerjen, bëni përpunimin e nevojshëm brenda funksionit handleGesture () # dhe pastaj rivendosni flamurin dhe bashkojeni sërish ndërprerësin detachInterrupt (0); handleGesture (); isr_flag = 0; attachInterrupt (0, interruptRutine, FALLING); } # ndonjë kod tjetër këtu ndoshta}

- përcaktoni funksionin handleGesture () ku mund të kërkojmë gjestin e fundit

void handleGesture () {

# nëse asnjë gjest nuk është kthimi i disponueshëm, ky është vetëm një kontroll i sigurt nëse (! apds.isGestureAvailable ()) {kthehet; } # lexon gjestin e fundit, krahasohet me ato të njohura dhe printon një ndërrues mesazhesh (apds.readGesture ()) {case DIR_UP: Serial.println ("UP"); pushim; rasti DIR_DOWN: Serial.println ("Poshtë"); pushim; rasti DIR_LEFT: Serial.println ("LEFT"); pushim; rasti DIR_RIGHT: Serial.println ("E DREJTA"); pushim; rasti DIR_FAR: Serial.println ("FAR"); pushim; }}

Tani le të shohim të gjithë kodin në veprim:

Kështu që unë kam shpjeguar API -në bazë të sensorit të gjesteve dhe unazës neopixel, tani le t'i bashkojmë gjërat:

Algoritmi funksionon kështu:

- inicimi i bibliotekave (shiko kodin e mësipërm)

- krijoni një sërë intensitetesh të udhëhequr të quajtur "ledStates". Ky grup do të përmbajë 24 intensitet të udhëhequr që janë rregulluar në mënyrë zbritëse nga 150 në 2

- brenda lakut kryesor kontrolloni nëse kunja e ndërprerjes është modifikuar nëse është kështu është koha për të ndryshuar animacionin ose ngjyrën e led

- funksioni "handleGesture ()" kontrollon gjestin e fundit dhe e quan funksionin "toggleColor" për gjestet UP -DOWN ose vendosni një ndryshore globale "ledDirection" për gjestet LEFT - Djathtas

- funksioni "toggleColor ()" thjesht ndryshon një ndryshore globale të quajtur "colorSelection" me një nga vlerat 0, 1, 2

- gjithashtu brenda funksionit të lakut kryesor një funksion tjetër i quajtur "animateLeds ();" quhet. Ky funksion kontrollon nëse kaluan 100 milisekonda, dhe nëse po, ai rrotullon ledet duke përdorur funksionin "rotateLeds ()" dhe pastaj i rishikon ato

- "rotateLeds ()" do të "rrotullojë" leds përpara ose prapa duke përdorur një grup tjetër të quajtur "intermediateLedStates".

"Efekti" i rrotullimit do të duket kështu:

# pas fillimit

{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 () quhet {0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # after rotateLeds () thirret përsëri {0, 0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # dhe kështu me radhë

Për këtë së pari krijon grupin e ri dhe kopjon intensitetet e vjetra të drejtuara në pozicionet e reja (rriteni pozicionin ose zvogëloni atë). Pas kësaj ajo mbishkruan grupin "ledStates" me "intermediateLedStates" kështu që procesi do të vazhdojë pas 100 milisekonda të tjera.

#përfshi "SparkFun_APDS9960.h"

#përfshi "Adafruit_NeoPixel.h"

#përfshi "Wire.h" #përcakto NEOPIXED_CONTROL_PIN 6 #përcakto NUM_LEDS 24 #përcakto APDS9960_INT 2 #përcakto LED_SPEED_STEP_INTERVAL 100 Rrip Adafruit_NeoPixel = Adafruit_NeoPixel (NEOPROBLET), NEO_GROBE, NEO_GROB_, SparkFun_APDS9960 apds = SparkFun_APDS9960 (); pa firmosur gjatë lastLedChangeTime = 0; ledDirection shkurtër = 0; ngjyra e shkurtërSelection = 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; void setup () {Serial.begin (9600); Serial.println ("Programi filloi"); strip.filloj (); pinMode (APDS9960_INT, INPUT); attachInterrupt (0, interruptRutine, FALLING); if (apds.init () && apds.enableGestureSensor (e vërtetë)) {Serial.println ("Fillimi i APDS-9960 i plotë"); } else {Serial.println ("Diçka shkoi keq gjatë APDS-9960 init!"); } lastLedChangeTime = milis (); Serial.println ("Fillo me sukses"); } void loop () {if (isr_flag == 1) {detachInterrupt (0); handleGesture (); isr_flag = 0; attachInterrupt (0, interruptRutine, FALLING); } animateLeds (); } void interruptRoutine () {isr_flag = 1; } / ** * Kjo do të trajtojë gjestet nga sensori APDS9960 * Gjestet lart e poshtë do të thërrasin funksionin toggleColor * Gjestet majtas dhe djathtas do të ndryshojnë animacionin e udhëhequr * / void handleGesture () {if (! Apds.isGestureAvailable ()) {kthimi; } switch (apds.readGesture ()) {case DIR_UP: Serial.println ("UP"); toggleColor (); pushim; rasti DIR_DOWN: Serial.println ("Poshtë"); toggleColor (); pushim; rasti DIR_LEFT: ledDirection = 1; Serial.println ("E majta"); pushim; rasti DIR_RIGHT: ledDirection = -1; Serial.println ("E DREJTA"); pushim; rasti DIR_FAR: ledDirection = 0; Serial.println ("FAR"); pushim; }} / ** * Ndryshoni ngjyrën aktuale të leds * Sa herë që ky funksion thirret do të ndryshojë gjendjen e leds * / void toggleColor () {if (colorSelection == 0) {colorSelection = 1; } else if (colorSelection == 1) {colorSelection = 2; } else {colorSelection = 0; }} / ** * Animacioni do të ekzekutohet pas LED_SPEED_STEP_INTERVAL milis * Së pari thirret funksioni rotateLeds, pastaj ngjyrat leds vendosen duke përdorur shiritin api * / void animateLeds () {if (millis () - lastLedChangeTime <LED_SPEED_STEP_INTERVAL) {kthim; } rotateLeds (); për (int i = 0; i <NUM_LEDS; i ++) {strip.setPixelColor (i, getColor (ledStates ))); shirit.shfaq (); } lastLedChangeTime = milis (); } /** * Duke përdorur një grup dytësor "intermediateLedStates", intensitetet e leds animohen * Së pari vlerat nga "ledStates" kopjohen në "intermediateLedStates" si kështu * le të ulemi vargu "ledStates" është {100, 80, 60, 0, 0, 0} dhe ledDirection është 1 * atëherë pasi ky funksion të quhet "ledStates" grupi është {0, 100, 80, 60, 0, 0} duke simuluar një efekt rrotullimi */ void rotateLeds () {byte intermediateLedStates [NUM_LEDS]; për (int i = 0; i <NUM_LEDS; i ++) {intermediateLedStates = 0; } për (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 ; }}} për (int i = 0; i <NUM_LEDS; i ++) {ledStates = intermediateLedStates ; }} uint32_t getColor (int intensiteti) {switch (colorSelection) {rasti 0: shiriti i kthimit. Ngjyra (intensiteti, 0, 0); rasti 1: shiriti i kthimit. Ngjyra (0, intensiteti, 0); parazgjedhur: shiriti i kthimit. Ngjyra (0, 0, intensiteti); }}

Shpresoj se ju ka pëlqyer kjo, mund të përdorni pjesën e komenteve për të më bërë pyetje.