Pagkontrol sa isang Neopixel Led Ring Na May Sensor ng Kilos: 3 Hakbang (na may Mga Larawan)

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:13

Sa tutorial na ito maglalaro kami gamit ang isang sensor ng kilos (APDS-9960) at isang neopixel ring upang malaman kung paano pagsamahin ang pareho sa paggamit ng isang Arduino UNO.

Ang pagtatapos na produkto ay tutugon sa kaliwa - kanang kilos sa pamamagitan ng animating na humantong kilusan kanan o kaliwa, at sa pataas na kilos sa pamamagitan ng pagbabago ng kulay ng leds.

Sa mga susunod na hakbang, maikli mong pangkalahatang-ideya ang listahan ng bahagi at kung paano ikonekta ang mga bahagi. At pagkatapos ay susuriin namin ang code ng hakbang-hakbang upang malaman kung paano ito gumagana.

Hakbang 1: Mga Bahagi

1. Arduino UNO

2. usb cable

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

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

5. mga cable na lalaki-babae, lalaki-lalaki na breadboard

6. breadboard

7. 5 V power supply para sa led ring (gumagamit ako ng isang 4 na baterya pabalik)

8. Upang ikabit ang singsing na neopixel sa breadboard kakailanganin mong maghinang ng tatlong mga lalaking pin dito: GND, PWR, at control pin. Para sa mga ito kailangan mo ng isang panghinang at pagkilos ng bagay

Ang mga pangunahing sangkap dito ay APDS-9960 gesture sensor at ang 24 neopixel ring. Maaari mong palitan ang iba't ibang mga arduino, usb cable power supply at mga breadboard na nais mo.

Hakbang 2: Assembly & Upload

Assembly

Bago ka magsimula tiyaking mayroon ka ng lahat ng mga sangkap sa iyong talahanayan. Magkakaroon kami ng ilang magagandang hakbang upang sundin:). Inilakip ko rin ang eskematiko ng Fritzing bilang isang larawan at nasa format din ng fritzing.

1. Solder 3 male pin sa neopixel ring (GND, PWR, control pin)

2. ikabit ang neopixel ring sa breadboard

3. ikabit ang APDS9960 sensor sa breadboard

4. ikonekta ang mga bakuran: baterya pack, arduino UNO, APDS9960 at neopixel sa groundboard ng tinapay

5. ikonekta ang lakas: arduino UNO 3V sa APDS9960 power pin, neopixel sa power pack ng baterya

6. ikonekta ang neopixel control pin sa arduino D6 pin

7. ikonekta ang SDA at SCL ng APDS9960 sa A4 at A5 ayon sa pagkakabanggit

8. ikonekta ang APDS9960 makagambala na pin sa arduino D2

Pag-upload ng code

Una sa lahat kakailanganin mong mag-download at mag-install ng mga kinakailangang aklatan ng arduino:

1. Neopixel ring library:

2. Library ng sensor ng kilos:

Kung hindi mo alam kung paano mag-install ng mga arduino library tingnan ang tutorial na ito.

Matapos mong ma-download at mai-install ang mga aklatan sa itaas, maaari mong i-clone o i-download ang aking arduino repository na matatagpuan dito: https://github.com/danionescu0/arduino, at gagamitin namin ang sketch na ito: https://github.com/danionescu0 / arduino / puno / master / proyekto / neopixel_ring_gestures

Sa susunod na seksyon i-embed ko ang code nang direkta sa tutorial na ito, kaya kung nais mo maaari mong kopyahin at i-paste ito mula doon.

Sa wakas ikonekta ang arduino ang computer gamit ang usb cable, ilagay ang 1.5 v na baterya sa baterya pack, at i-upload ang sketch sa arduino.

Hakbang 3: Paano Ito Gumagana?

Sa huling bahaging ito malalaman natin kung paano pinagsama ang mga sangkap na ito, kung paano gamitin ang kanilang mga aklatan at kung paano ko nabuo ang aking code:

Kumuha muna tayo ng isang mabilis na sulyap sa pamamagitan ng sensor at mga pamamaraan ng neopixel library API na gagamitin namin

1. Neopixel API mula sa adafruit

Mula sa library na ito gagamitin namin ang mga pamamaraan na kontrolin ang kulay ng bawat led at ilapat ang mga ito

- isama ang library:

# isama

- ideklara ang silid-aklatan

# tukuyin NEOPIXED_CONTROL_PIN 6

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

- magpasimula

# Karaniwan sa loob ng pag-setup block

void setup () {strip.begin (); # baka ilang ibang gamit dito #…. }

- sindihan ang mga indibidwal na mga pixel pagkatapos ay ilapat ang lahat ng mga pagbabago sa strip (i-render ito sa isang paraan)

# i-set up ang pixel 0 upang maging pula

strip.setPixelColor (0, strip. Color (255, 0, 0)); # set up ang pixel 1 upang maging green strip.setPixelColor (1, strip. Color (0, 255, 0)); # i-set up ang pixel 2 upang maging asul na strip.setPixelColor (2, strip. Color (0, 0 255)); strip.show ();

2. APDS 9960 kilos sensor

Mula sa silid-aklatan na ito gagamitin namin ang pagpapaandar na "basahin ang kilos". Ang function na ito ay magagawang makilala sa pagitan ng kaliwa-kanan, pataas, pababa, malayo na mga utos. Mayroong isang trick dito, hindi namin tatanungin ang sensor nang tuloy-tuloy para sa huling kilos na nakita. Ang board ay may kakayahan na "ping" sa pamamagitan ng isang nakakagambala na natagpuan ang isang kilos.

- isama ang library, katulad ng neopixel

- ideklara sa silid-aklatan ang makagambala na pin, at ang gumambala na bandila

# tukuyin ang APDS9960_INT 2

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

- ipasimula ang library, karaniwang nasa loob ng pag-andar ng pag-setup

walang bisa ang pag-setup ()

{# ideklara ang makagambala na pin bilang INPUT at maglakip ng isang pagpapaandar dito pinMode (APDS9960_INT, INPUT); attachInterrupt (0, interruptRoutine, FALLING); kung (apds.init () && apds.enableGestureSensor (totoo)) {Serial.println ("APDS-9960 kumpleto na pagsisimula"); } iba pa {Serial.println ("May nangyaring mali sa panahon ng APDS-9960 init!"); } # ipasimula ang ibang mga bagay siguro}

- tukuyin ang nakakagambala na pag-andar, dito lamang kami magtatakda ng isang watawat

walang bisa interruptRoutine () {

isr_flag = 1; }

- Sa loob ng pag-andar ng loop ay suriin pana-panahon ang watawat upang makita kung may nakita ang isang kilos

walang bisa loop ()

{# suriin ang watawat kung (isr_flag == 1) {# kung nakatakda ang watawat, alisin ang abala, gawin ang kinakailangang pagproseso sa loob ng function na function naGesture () at pagkatapos ay i-reset ang bandila at i-reachach ang nakakagambala na detachInterrupt (0); hawakanGesture (); isr_flag = 0; attachInterrupt (0, interruptRoutine, FALLING); } # ilang iba pang code dito siguro}

- tukuyin ang function na handleGesture () kung saan maaari nating hilingin ang huling kilos

void handleGesture () {

# kung walang kilos na magagamit ang pagbabalik, ligtas lamang itong suriin kung (! apds.isGestureAvailable ()) {return; } Basahin ng # ang huling kilos, ihinahambing sa mga kilala at i-print ang isang switch ng mensahe (apds.readGesture ()) {case DIR_UP: Serial.println ("UP"); pahinga; kaso DIR_DOWN: Serial.println ("Pababa"); pahinga; case DIR_LEFT: Serial.println ("LEFT"); pahinga; kaso DIR_RIGHT: Serial.println ("RIGHT"); pahinga; kaso DIR_FAR: Serial.println ("FAR"); pahinga; }}

Tingnan natin ngayon ang buong code sa pagkilos:

Kaya't ipinaliwanag ko ang batayang API ng sensor ng kilos at ang neopixel ring, ngayon ay pagsamahin natin ang mga bagay:

Tumatakbo ang algorithm tulad nito:

- ipasimula ang mga aklatan (tingnan ang code sa itaas)

- Lumikha ng isang hanay ng mga led intensities na tinatawag na "ledStates". Maglalaman ang array na ito ng 24 led intensities na nakaayos sa isang pababang paraan mula 150 hanggang 2

- Sa loob ng pangunahing tseke ng loop kung ang makagambala na pin ay nabago kung kaya oras na upang baguhin ang animasyon o kulay ng led

- ang function na "handleGesture ()" ay sumusuri sa huling kilos at tinawag ang function na "toggleColor" para sa mga kilos na UP -DOWN o magtakda ng isang pandaigdigang variable na "ledDirection" para sa Kaliwang - KARAPAT na kilos

- ang function na "toggleColor ()" ay binabago lamang ang isang pandaigdigang variable na pinangalanang "colorSelection" na may isa sa mga halagang 0, 1, 2

- nasa loob din ng pangunahing pag-andar ng loop ang isa pang pagpapaandar na pinangalanang "animateLeds ();" ay tinatawag na. Sinusuri ng pagpapaandar na ito kung 100 milliseconds ang lumipas, at kung gayon paikutin nito ang mga leds gamit ang "rotateLeds ()" na function at pagkatapos ay i-redraw ang mga ito

- ang "rotateLeds ()" ay "paikutin" ang mga leds pasulong o paatras sa pamamagitan ng paggamit ng isa pang array na tinatawag na "intermediateLedStates".

Magiging ganito ang pag-ikot ng "epekto":

# pagkatapos ng pagsisimula

{150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; Ang # pagkatapos ng rotateLeds () ay tinawag na {0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # pagkatapos ng rotateLeds () ay tinawag ulit na {0, 0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # at iba pa

Para sa mga ito unang nilikha ang bagong array at kopyahin ang lumang humantong intensities sa mga bagong posisyon (dagdagan ang posisyon o bawasan ito). Pagkatapos nito ay mai-o-overtake ang array na "ledStates" gamit ang "intermediateLedStates" kaya't magpapatuloy ang proseso pagkatapos ng isa pang 100 milliseconds.

# isama ang "SparkFun_APDS9960.h"

# isama ang "Adafruit_NeoPixel.h"

# isama ang "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, NEOPIXED_CON) SparkFun_APDS9960 apds = SparkFun_APDS9960 (); unsigned matagal lastLedChangeTime = 0; maikling ledDirection = 0; maikling kulaySeleksyon = 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}; int isr_flag = 0; void setup () {Serial.begin (9600); Serial.println ("Nagsimula ang programa"); strip.begin (); pinMode (APDS9960_INT, INPUT); attachInterrupt (0, interruptRoutine, FALLING); kung (apds.init () && apds.enableGestureSensor (totoo)) {Serial.println ("APDS-9960 kumpleto na pagsisimula"); } iba pa {Serial.println ("May nangyaring mali sa panahon ng APDS-9960 init!"); } lastLedChangeTime = millis (); Serial.println ("Init succesful"); } void loop () {if (isr_flag == 1) {detachInterrupt (0); hawakanGesture (); isr_flag = 0; attachInterrupt (0, interruptRoutine, FALLING); } animateLeds (); } walang bisa interruptRoutine () {isr_flag = 1; } / ** * Hahawakan nito ang mga kilos mula sa sensor ng APDS9960 * Ang mga pataas at Pababa na kilos ay tatawag sa toggleColor function * Kaliwa at Kanan na kilos ay magbabago ng humantong animasyon * / walang bisa na handleGesture () {kung (! Apds.isGestureAvailable ()) {return; } switch (apds.readGesture ()) {case DIR_UP: Serial.println ("UP"); toggleColor (); pahinga; kaso DIR_DOWN: Serial.println ("Pababa"); toggleColor (); pahinga; kaso DIR_LEFT: ledDirection = 1; Serial.println ("KALIWA"); pahinga; kaso DIR_RIGHT: ledDirection = -1; Serial.println ("TAMA"); pahinga; kaso DIR_FAR: ledDirection = 0; Serial.println ("FAR"); pahinga; }} / ** * Baguhin ang kasalukuyang kulay ng leds * Sa tuwing tatawagin ang pagpapaandar na ito ay babaguhin ang estado ng leds * / void toggleColor () {if (colorSelection == 0) {colorSelection = 1; } iba pa kung (colorSelection == 1) {colorSelection = 2; } iba pa {colorSelection = 0; }} / ** * Tatakbo ang animation pagkatapos ng LED_SPEED_STEP_INTERVAL millis * Una na ang function ng rotateLeds ay tinawag, pagkatapos ang mga kulay ng leds ay itinakda gamit ang strip api * / void animateLeds () {if (millis () - lastLedChangeTime <LED_SPEED_STEP_INTERVAL) {return; } rotateLeds (); para sa (int i = 0; i <NUM_LEDS; i ++) {strip.setPixelColor (i, getColor (ledStates )); strip.show (); } lastLedChangeTime = millis (); } / ** * Gamit ang pangalawang array na "intermediateLedStates", ang mga intensidad ng leds ay na-animate * Una ang mga halagang mula sa "ledStates" ay nakopya sa "intermediateLedStates" tulad ng kaya * upuan natin ang array na "ledStates" ay {100, 80, 60, 0, 0, 0} at ang ledDirection ay 1 * pagkatapos pagkatapos ng pagpapaandar na ito ay tinawag na "ledStates" na array ay {0, 100, 80, 60, 0, 0} na tumutulad sa isang rotation effect * / void rotateLeds () {byte intermediateLedStates [NUM_LEDS]; para sa (int i = 0; i <NUM_LEDS; i ++) {intermediateLedStates = 0; } para sa (int i = 0; i <NUM_LEDS; i ++) {if (ledDirection == 1) {if (i == NUM_LEDS -1) {intermediateLedStates [0] = ledStates ; } iba pa {intermediateLedStates [i + 1] = ledStates ; }} iba pa {kung (i == 0) {intermediateLedStates [NUM_LEDS - 1] = ledStates ; } iba pa {intermediateLedStates [i - 1] = ledStates ; }}} para sa (int i = 0; i <NUM_LEDS; i ++) {ledStates = intermediateLedStates ; }} uint32_t getColor (int intensity) {switch (colorSelection) {case 0: return strip. Color (intensity, 0, 0); kaso 1: return strip. Kulay (0, intensity, 0); default: return strip. Kulay (0, 0, intensity); }}

Inaasahan kong nasiyahan ka dito, maaari mong gamitin ang seksyon ng mga puna upang magtanong sa akin.