Styring af en Neopixel Led -ring med en gestusensor: 3 trin (med billeder)

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:28

I denne vejledning skal vi lege med en gestusensor (APDS-9960) og en neopixelring for at lære at kombinere dem begge ved hjælp af en Arduino UNO.

Slutproduktet reagerer på venstre - højre bevægelser ved at animere led -bevægelse til højre eller venstre og til opad -nedadgående bevægelser ved at ændre lysdiodernes farve.

I de næste trin får du en kort oversigt over delelisten og hvordan du forbinder komponenterne. Og så gennemgår vi koden trin for trin for at lære, hvordan den fungerer.

Trin 1: Komponenter

1. Arduino UNO

2. usb -kabel

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

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

5. han-hun, han-han-brødbrætkabler

6. brødbræt

7. 5 V strømforsyning til LED -ringen (jeg bruger en 4 batteri tilbage)

8. For at fastgøre neopixelringen til brødbrættet skal du lodde tre hanstifter til den: GND, PWR og kontrolnål. Til dette skal du bruge et loddejern og flux

Hovedkomponenterne her er APDS-9960 gestusensor og den 24 neopixelring. Du kan skifte forskellige arduinoer, usb -kabler strømforsyninger og brødbrætter, som du ønsker.

Trin 2: Montering og upload

montage

Inden du går i gang, skal du sørge for at have alle komponenterne på bordet. Vi har nogle gode trin at følge:). Jeg har også vedhæftet Fritzing -skematikken som et billede og også i fritzing -format.

1. Lod lod 3 hanstifter til neopixelringen (GND, PWR, kontrolnål)

2. fastgør neopixelringen til brødbrættet

3. fastgør APDS9960 -sensoren til brødbrættet

4. tilslut grunde: batteripakke, arduino UNO, APDS9960 og neopixel til brødbrættet

5. tilslut strømmen: arduino UNO 3V til APDS9960 power pin, neopixel til batteripakke

6. tilslut neopixel -kontrolstiften til arduino D6 -ben

7. tilslut SDA og SCL på APDS9960 til henholdsvis A4 og A5

8. tilslut APDS9960 afbrydelsesstift til arduino D2

Upload af kode

Først og fremmest skal du downloade og installere de nødvendige arduino -biblioteker:

1. Neopixel -ringbibliotek:

2. Gesture sensor bibliotek:

Hvis du ikke ved, hvordan du installerer arduino -biblioteker, kan du tjekke denne vejledning.

Når du har downloadet og installeret bibliotekerne ovenfor, kan du klone eller downloade mit arduino -depot placeret her: https://github.com/danionescu0/arduino, og vi vil bruge denne skitse: https://github.com/danionescu0 /arduino/tree/master/projects/neopixel_ring_gestures

I det næste afsnit vil jeg integrere koden direkte i denne vejledning, så hvis du vil kan du kopiere og indsætte den derfra.

Tilslut til sidst arduino computeren ved hjælp af usb -kablet, sæt 1,5 v batterier i batteripakken, og upload skitsen til arduinoen.

Trin 3: Hvordan fungerer det?

I denne sidste del lærer vi, hvordan disse komponenter kombineres sammen, hvordan de bruger deres biblioteker, og hvordan jeg har struktureret min kode:

Lad os først få et hurtigt blik gennem sensoren og neopixelbibliotekets API -metoder, som vi vil bruge

1. Neopixel API fra adafruit

Fra dette bibliotek bruger vi de metoder, der styrer den enkelte ledes farve og anvender dem

- omfatte biblioteket:

#omfatte

- erklære biblioteket

#define NEOPIXED_CONTROL_PIN 6

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

- initialisere

#typisk inde i installationsblokken

ugyldig opsætning () {strip.begin (); # måske nogle andre ting her #…. }

- tænd individuelle pixels, og anvend derefter alle ændringer på båndet (gengiv det på en måde)

# konfigurer pixel 0 til at være rød

strip.setPixelColor (0, strip. Color (255, 0, 0)); # opsæt pixel 1 til at være grøn strip.setPixelColor (1, strip. Color (0, 255, 0)); # opsæt pixel 2 til at være blå strip.setPixelColor (2, strip. Color (0, 0 255)); strip.show ();

2. APDS 9960 gestusensor

Fra dette bibliotek bruger vi funktionen "læs gestus". Denne funktion vil være i stand til at skelne mellem venstre-højre, op-ned, tæt-langt kommandoer. Der er et trick her, vi vil ikke bede sensoren løbende om den sidste gestus, der opfattes. Brættet har evnen til at "pinge" gennem en afbrydelse, at der er fundet en gestus.

- omfatte biblioteket, svarende til neopixel

- erklære biblioteket for afbrydelsesnålen og afbrydelsesflaget

#define APDS9960_INT 2

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

- initialiser biblioteket, typisk inde i opsætningsfunktionen

ugyldig opsætning ()

{ # erklær afbrydelsesnålen som INPUT, og tilknyt en funktion til den pinMode (APDS9960_INT, INPUT); attachInterrupt (0, interruptRoutine, FALLING); if (apds.init () && apds.enableGestureSensor (true)) {Serial.println ("APDS-9960 initialisering fuldført"); } else {Serial.println ("Noget gik galt under APDS-9960 init!"); } # initialiser andre ting måske}

- definer afbrydelsesfunktionen, her sætter vi kun et flag

void interruptRoutine () {

isr_flag = 1; }

- inde i loop -funktionen skal du kontrollere flaget med jævne mellemrum for at se, om der er registreret en gestus

hulrum ()

{ # tjek flaget, hvis (isr_flag == 1) { # hvis flaget er indstillet, fjern afbrydelsen, foretag den nødvendige behandling inde i handleGesture () -funktionen # og nulstil derefter flaget, og sæt afbrydelsesdetachInterrupt (0) på igen; handleGesture (); isr_flag = 0; attachInterrupt (0, interruptRoutine, FALLING); } # måske en anden kode her}

- definer handleGesture () -funktion, hvor vi kan bede om den sidste gestus

void handleGesture () {

# hvis ingen gest er tilgængelig tilbagevenden, er dette kun en sikker kontrol af, om (! apds.isGestureAvailable ()) {return; } # læser den sidste gestus, sammenligner med de kendte og udskriver en beskedkontakt (apds.readGesture ()) {case DIR_UP: Serial.println ("UP"); pause; sag DIR_DOWN: Serial.println ("NED"); pause; sag DIR_LEFT: Serial.println ("LEFT"); pause; sag DIR_RIGHT: Serial.println ("RIGHT"); pause; sag DIR_FAR: Serial.println ("FAR"); pause; }}

Lad os nu se hele koden i aktion:

Så jeg har forklaret basis -API'en for gestusensoren og neopixelringen, lad os nu sætte tingene sammen:

Algoritmen kører således:

- initialiser bibliotekerne (se koden ovenfor)

- opret en række led -intensiteter kaldet "ledStates". Denne matrix vil indeholde 24 led -intensiteter, der er arrangeret på en faldende måde fra 150 til 2

- inden i hovedsløjfen, skal du kontrollere, om afbrydelsesnålen er ændret, hvis det er tilfældet, er det tid til at ændre ledets animation eller farve

- funktionen "handleGesture ()" kontrollerer den sidste gestus og kalder funktionen "toggleColor" for OP -NED -bevægelser eller indstil en global variabel "ledDirection" for LEFT - RIGHT -bevægelser

- funktionen "toggleColor ()" ændrer ganske enkelt en global variabel med navnet "colorSelection" med en af værdierne 0, 1, 2

- også inde i hovedsløjfe -funktionen en anden funktion ved navn "animateLeds ();" Hedder. Denne funktion kontrollerer, om der er gået 100 millisekunder, og i så fald roterer den lysdioderne ved hjælp af funktionen "rotateLeds ()" og tegner dem derefter igen

- "rotateLeds ()" vil "rotere" lysdioderne frem eller tilbage ved hjælp af et andet array kaldet "intermediateLedStates".

Rotationens "effekt" vil se sådan ud:

# efter initialisering

{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}; # efter rotateLeds () kaldes {0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # efter rotateLeds () kaldes igen {0, 0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # og så videre

For dette opretter først det nye array og kopierer de gamle led -intensiteter på de nye positioner (øg positionen eller formindsk den). Derefter overskriver det "ledStates" -arrayet med "intermediateLedStates", så processen vil fortsætte efter yderligere 100 millisekunder.

#include "SparkFun_APDS9960.h"

#include "Adafruit_NeoPixel.h"

#inkludere "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, NEOPIX_NEZO_NED_NEO_NED_NEO_NEDE_NEO_PRODUKTER, NEOPIX_NED) SparkFun_APDS9960 apds = SparkFun_APDS9960 (); unsigned long 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; ugyldig opsætning () {Serial.begin (9600); Serial.println ("Program startet"); strip.begin (); pinMode (APDS9960_INT, INPUT); attachInterrupt (0, interruptRoutine, FALLING); if (apds.init () && apds.enableGestureSensor (true)) {Serial.println ("APDS-9960 initialisering fuldført"); } else {Serial.println ("Noget gik galt under APDS-9960 init!"); } lastLedChangeTime = millis (); Serial.println ("Init succesfuldt"); } void loop () {if (isr_flag == 1) {detachInterrupt (0); handleGesture (); isr_flag = 0; attachInterrupt (0, interruptRoutine, FALLING); } animateLeds (); } void interruptRoutine () {isr_flag = 1; } / ** * Dette håndterer bevægelser fra APDS9960 -sensoren * Op og ned -bevægelser kalder toggleColor -funktion * Venstre og højre gestus ændrer LED -animationen * / void handleGesture () {if (! Apds.isGestureAvailable ()) {return; } switch (apds.readGesture ()) {case DIR_UP: Serial.println ("UP"); toggleColor (); pause; sag DIR_DOWN: Serial.println ("NED"); toggleColor (); pause; sag DIR_LEFT: ledDirection = 1; Serial.println ("LEFT"); pause; sag DIR_RIGHT: ledDirection = -1; Serial.println ("HØJRE"); pause; sag DIR_FAR: ledDirection = 0; Serial.println ("FAR"); pause; }} / ** * Skift nuværende lysdiodes farve * Hver gang denne funktion kaldes, ændres lysdiodernes tilstand * / void toggleColor () {if (colorSelection == 0) {colorSelection = 1; } ellers hvis (colorSelection == 1) {colorSelection = 2; } ellers {colorSelection = 0; }} / ** * Animationen kører efter LED_SPEED_STEP_INTERVAL millis * Først kaldes funktionen rotateLeds, derefter indstilles leds -farverne ved hjælp af stripen 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 (); } /** * Ved hjælp af en sekundær matrix "intermediateLedStates" animeres lysdiodernes intensiteter * Først kopieres værdierne fra "ledStates" på "intermediateLedStates" som så * lad os sætte "ledStates" arrayet er {100, 80, 60, 0, 0, 0} og ledDirection er 1 *, efter at denne funktion kaldes "ledStates", er array {0, 100, 80, 60, 0, 0} simulerende en rotationseffekt */ void rotateLeds () {byte 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 ; }} andet {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 intensitet) {switch (colorSelection) {case 0: return strip. Color (intensitet, 0, 0); sag 1: returstrimmel. Farve (0, intensitet, 0); standard: returstrimmel. Farve (0, 0, intensitet); }}

Jeg håber du nød dette, du kan bruge kommentarfeltet til at stille mig spørgsmål.