Controlul unui inel cu led Neopixel cu senzor de gesturi: 3 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

În acest tutorial ne vom juca cu un senzor de gesturi (APDS-9960) și un inel de neopixel pentru a afla cum să le combinăm pe amândouă folosind un Arduino UNO.

Produsul final va răspunde la gesturile stânga - dreapta prin animarea mișcării ledului spre dreapta sau spre stânga și la gesturile sus-jos prin schimbarea culorii ledurilor.

În pașii următori, veți face o scurtă prezentare generală a listei de piese și a modului de conectare a componentelor. Și apoi vom examina codul pas cu pas pentru a afla cum funcționează.

Pasul 1: Componente

1. Arduino UNO

2. cablu USB

3. Senzor de gest APDS9960 (https://www.sparkfun.com/products/12787)

4. 24 de inele cu led neopixel (https://www.adafruit.com/product/1586)

5. Cabluri de panou de masă-mamă, mascul-mascul

6. panou de masă

7. Sursă de alimentare de 5 V pentru inelul cu led (folosesc o baterie din spate cu 4)

8. Pentru a atașa inelul de neopixel la panoul de testare, va trebui să lipiți trei pini masculi pe acesta: GND, PWR și pinul de control. Pentru aceasta veți avea nevoie de un fier de lipit și un flux

Principalele componente aici sunt senzorul de gest APDS-9960 și inelul de 24 de neopixeli. Puteți comuta diferite arduino, cabluri USB, surse de alimentare și plăci de calcul, după cum doriți.

Pasul 2: Asamblare și încărcare

Asamblare

Înainte de a începe, asigurați-vă că aveți toate componentele pe masa dvs. Vom avea câțiva pași frumoși de urmat:). Am atașat, de asemenea, schema Fritzing ca imagine și, de asemenea, în format fritzing.

1. Lipiți 3 pini masculi la inelul de neopixel (GND, PWR, pin de control)

2. atașați inelul de neopixel la panoul de măsurare

3. atașați senzorul APDS9960 la panoul de control

4. conectați terenul: baterie, arduino UNO, APDS9960 și neopixel la masa panoului

5. Conectați puterea: arduino UNO 3V la pinul de alimentare APDS9960, neopixel la baterie

6. conectați pinul de control neopixel la pinul arduino D6

7. conectați SDA și SCL ale APDS9960 la A4 și respectiv A5

8. conectați pinul de întrerupere APDS9960 la arduino D2

Încărcare cod

În primul rând va trebui să descărcați și să instalați bibliotecile arduino necesare:

1. Biblioteca de inele Neopixel:

2. Biblioteca senzorului de gesturi:

Dacă nu știți cum să instalați bibliotecile arduino, consultați acest tutorial.

După ce ați descărcat și instalat bibliotecile de mai sus, puteți clona sau descărca depozitul meu arduino situat aici: https://github.com/danionescu0/arduino și vom folosi această schiță: https://github.com/danionescu0 / arduino / tree / master / projects / neopixel_ring_gestures

În secțiunea următoare voi încorpora codul direct în acest tutorial, așa că, dacă doriți, îl puteți copia și lipi de acolo.

În cele din urmă, conectați arduino-ul la computer utilizând cablul USB, puneți baterii de 1,5 V în acumulator și încărcați schița în arduino.

Pasul 3: Cum funcționează?

În această ultimă parte vom afla cum aceste componente sunt combinate împreună, cum să le folosesc bibliotecile și cum mi-am structurat codul:

Mai întâi să aruncăm o privire rapidă prin senzor și metodele API ale bibliotecii neopixeli pe care le vom folosi

1. API Neopixel de la adafruit

Din această bibliotecă vom folosi metodele care controlează culoarea ledului individual și le aplicăm

- include biblioteca:

#include

- declarați biblioteca

#define NEOPIXED_CONTROL_PIN 6

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

- inițializează

#tipic în interiorul blocului de configurare

void setup () {strip.begin (); # poate alte lucruri aici # … }

- aprindeți pixeli individuali apoi aplicați toate modificările benzii (redați-le într-un fel)

# configurați pixelul 0 pentru a fi roșu

strip.setPixelColor (0, strip. Color (255, 0, 0)); # configurați pixelul 1 să fie verde strip.setPixelColor (1, strip. Color (0, 255, 0)); # configurați pixelul 2 pentru a fi albastru strip.setPixelColor (2, strip. Color (0, 0 255)); strip.show ();

2. Senzor de gest APDS 9960

Din această bibliotecă vom folosi funcția „gest de citire”. Această funcție va putea distinge între comenzi stânga-dreapta, sus-jos, aproape-departe. Există un truc aici, nu vom cere senzorului continuu ultimul gest perceput. Consiliul are capacitatea de a „face ping” printr-o întrerupere că a fost găsit un gest.

- include biblioteca, similară cu neopixelul

- declarați biblioteca pinul de întrerupere și semnalizatorul de întrerupere

#define APDS9960_INT 2

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

- inițializați biblioteca, de obicei în cadrul funcției de configurare

configurare nulă ()

{# declarați pinul de întrerupere ca INPUT și atașați o funcție pinMode (APDS9960_INT, INPUT); attachInterrupt (0, interruptRoutine, FALLING); if (apds.init () && apds.enableGestureSensor (true)) {Serial.println ("APDS-9960 initialization complete"); } else {Serial.println ("Ceva nu a funcționat în timpul inițierii APDS-9960!"); } # inițializează alte lucruri poate}

- definiți funcția de întrerupere, aici vom seta doar un steag

void interruptRoutine () {

isr_flag = 1; }

- în interiorul funcției buclă verificați periodic semnalizatorul pentru a vedea dacă a fost detectat un gest

bucla nulă ()

{# verificați steagul dacă (isr_flag == 1) {# dacă steagul este setat, eliminați întreruperea, efectuați procesarea necesară în funcția handleGesture () # și apoi resetați steagul și reatașați întreruperea detachInterrupt (0); handleGesture (); isr_flag = 0; attachInterrupt (0, interruptRoutine, FALLING); } # alt cod aici poate}

- definiți funcția handleGesture () unde putem solicita ultimul gest

void handleGesture () {

# dacă niciun gest nu este returnabil, aceasta este doar o verificare sigură dacă (! apds.isGestureAvailable ()) {returnează; } # citește ultimul gest, compară cu cele cunoscute și tipărește un comutator de mesaj (apds.readGesture ()) {case DIR_UP: Serial.println ("UP"); pauză; caz DIR_DOWN: Serial.println ("DOWN"); pauză; caz DIR_LEFT: Serial.println ("STÂNGA"); pauză; caz DIR_RIGHT: Serial.println ("DREAPTA"); pauză; cazul DIR_FAR: Serial.println ("FAR"); pauză; }}

Acum să vedem întregul cod în acțiune:

Așa că am explicat API-ul de bază al senzorului de gesturi și al inelului de neopixeli, acum să punem lucrurile împreună:

Algoritmul rulează astfel:

- inițializează bibliotecile (vezi codul de mai sus)

- creați o serie de intensități led numite „ledStates”. Această matrice va conține 24 de intensități led care sunt aranjate într-un mod descendent de la 150 la 2

- în interiorul buclei principale verificați dacă pinul de întrerupere a fost modificat, dacă este cazul, este timpul să schimbați animația sau culoarea ledului

- funcția „handleGesture ()” verifică ultimul gest și apelează funcția „toggleColor” pentru gesturi SUS-JOS sau setează o variabilă globală „ledDirection” pentru gesturile STÂNGA - DREAPTA

- funcția "toggleColor ()" schimbă pur și simplu o variabilă globală numită "colorSelection" cu una dintre valorile 0, 1, 2

- de asemenea, în interiorul funcției buclei principale, o altă funcție numită "animateLeds ();" se numește. Această funcție verifică dacă au trecut 100 de milisecunde și, în caz afirmativ, rotește ledurile folosind funcția "rotateLeds ()" și apoi le redesenează

- „rotateLeds ()” va „roti” ledurile înainte sau înapoi utilizând o altă matrice numită „stateLed intermediare”.

„Efectul” de rotație va arăta astfel:

# după inițializare

{150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # după rotateLeds () se numește {0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # după ce rotateLeds () este apelat din nou {0, 0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # si asa mai departe

Pentru aceasta creează mai întâi noua matrice și copiază vechile intensități ale ledurilor pe noile poziții (creșteți poziția sau descreșteți-o). După aceea, suprascrie matricea "ledStates" cu "intermediarLedStates", astfel încât procesul va continua după alte 100 de milisecunde.

#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, NEOPIXED_CONTROL_P; SparkFun_APDS9960 apds = SparkFun_APDS9960 (); unsigned long lastLedChangeTime = 0; direcție scurtă led = 0; scurt colorSelection = 0; octet 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 („Programul a început”); strip.begin (); pinMode (APDS9960_INT, INPUT); attachInterrupt (0, interruptRoutine, FALLING); if (apds.init () && apds.enableGestureSensor (true)) {Serial.println ("APDS-9960 initialization complete"); } else {Serial.println ("Ceva nu a funcționat în timpul inițierii APDS-9960!"); } lastLedChangeTime = millis (); Serial.println ("Init cu succes"); } void loop () {if (isr_flag == 1) {detachInterrupt (0); handleGesture (); isr_flag = 0; attachInterrupt (0, interruptRoutine, FALLING); } animateLeds (); } void interruptRoutine () {isr_flag = 1; } / ** * Acest lucru va gestiona gesturile de la senzorul APDS9960 * Gesturile în sus și în jos vor apela funcția toggleColor * Gesturile din stânga și din dreapta vor schimba animația LED * / void handleGesture () {if (! Apds.isGestureAvailable ()) {return; } switch (apds.readGesture ()) {case DIR_UP: Serial.println ("UP"); toggleColor (); pauză; caz DIR_DOWN: Serial.println ("DOWN"); toggleColor (); pauză; caz DIR_LEFT: ledDirection = 1; Serial.println („STÂNGA”); pauză; caz DIR_RIGHT: ledDirection = -1; Serial.println („DREAPTA”); pauză; caz DIR_FAR: ledDirection = 0; Serial.println ("FAR"); pauză; }} / ** * Schimbați culoarea ledurilor curente * De fiecare dată când se apelează această funcție se va schimba starea ledurilor * / void toggleColor () {if (colorSelection == 0) {colorSelection = 1; } else if (colorSelection == 1) {colorSelection = 2; } else {colorSelection = 0; }} / ** * Animația va rula după LED_SPEED_STEP_INTERVAL millis * Mai întâi se apelează funcția rotateLeds, apoi culorile ledurilor sunt setate folosind banda 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 (); } / ** * Folosind un tablou secundar „intermediarLedStates”, intensitățile led-urilor sunt animate * Mai întâi valorile din „ledStates” sunt copiate pe „intermediarLedStates” așa * să stăm matricea „ledStates” este {100, 80, 60, 0;]; 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 {stateLed intermediare [i + 1] = ledStates ; }} else {if (i == 0) {intermediateLedStates [NUM_LEDS - 1] = ledStates ; } else {stateLed intermediare [i - 1] = ledStates ; }}} pentru (int i = 0; i <NUM_LEDS; i ++) {ledStates = intermediateLedStates ; }} uint32_t getColor (int intensitate) {switch (colorSelection) {case 0: return strip. Color (intensitate, 0, 0); caz 1: bandă de întoarcere. Culoare (0, intensitate, 0); implicit: return strip. Color (0, 0, intensitate); }}

Sper că ți-a plăcut acest lucru, poți folosi secțiunea de comentarii pentru a-mi pune întrebări.