Een Neopixel Led Ring bedienen met een bewegingssensor - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

In deze tutorial gaan we spelen met een bewegingssensor (APDS-9960) en een neopixelring om te leren hoe je ze beide kunt combineren met een Arduino UNO.

Het eindproduct reageert op links-rechtsgebaren door ledbewegingen naar rechts of links te animeren, en op omhoog-omlaagbewegingen door de kleur van de leds te veranderen.

In de volgende stappen krijg je een kort overzicht van de onderdelenlijst en hoe je de componenten aansluit. En dan zullen we de code stap voor stap bekijken om te leren hoe het werkt.

Stap 1: Componenten

1. Arduino UNO

2. usb-kabel

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

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

5. mannelijk-vrouwelijk, mannelijk-mannelijk breadboard-kabels

6. breadboard

7. 5 V-voeding voor de led-ring (ik gebruik een batterij met 4 batterijen)

8. Om de neopixelring aan het breadboard te bevestigen, moet je er drie mannelijke pinnen aan solderen: GND, PWR en controlepin. Hiervoor heb je een soldeerbout en vloeimiddel nodig

De belangrijkste componenten hier zijn de APDS-9960-bewegingssensor en de ring met 24 neopixels. Je kunt naar wens verschillende arduino's, usb-kabels, voedingen en breadboards wisselen.

Stap 2: Montage en uploaden

samenkomst

Zorg ervoor dat u alle componenten op tafel heeft voordat u aan de slag gaat. We hebben een aantal leuke stappen om te volgen:). Ik heb het Fritzing-schema ook als afbeelding bijgevoegd en ook in fritzing-formaat.

1. Soldeer 3 mannelijke pinnen aan de neopixelring (GND, PWR, controlepin)

2. bevestig de neopixel-ring aan het breadboard

3. bevestig de APDS9960-sensor aan het breadboard

4. sluit de gronden aan: batterijpakket, arduino UNO, APDS9960 en neopixel op de breadboard-grond

5. sluit de voeding aan: arduino UNO 3V naar APDS9960 power pin, neopixel naar batterijvoeding

6. sluit de neopixel-controlepin aan op de arduino D6-pin

7. sluit SDA en SCL van de APDS9960 respectievelijk aan op de A4 en A5

8. sluit de APDS9960 interrupt pin aan op de arduino D2

Code uploaden

Allereerst moet je de benodigde arduino-bibliotheken downloaden en installeren:

1. Neopixel-ringbibliotheek:

2. Bibliotheek met gebarensensoren:

Als je niet weet hoe je arduino-bibliotheken moet installeren, bekijk dan deze tutorial.

Nadat je de bovenstaande bibliotheken hebt gedownload en geïnstalleerd, kun je mijn arduino-repository klonen of downloaden die zich hier bevindt: https://github.com/danionescu0/arduino, en we zullen deze schets gebruiken: https://github.com/danionescu0 /arduino/tree/master/projects/neopixel_ring_gestures

In het volgende gedeelte zal ik de code rechtstreeks in deze zelfstudie insluiten, dus als je wilt, kun je deze vanaf daar kopiëren en plakken.

Sluit ten slotte de arduino aan op de computer met behulp van de usb-kabel, plaats 1,5 v-batterijen in het batterijpakket en upload de schets naar de arduino.

Stap 3: Hoe werkt het?

In dit laatste deel zullen we leren hoe deze componenten worden gecombineerd, hoe hun bibliotheken te gebruiken en hoe ik mijn code heb gestructureerd:

Laten we eerst een snelle blik werpen op de sensor en de neopixel-bibliotheek-API-methoden die we zullen gebruiken

1. Neopixel-API van adafruit

Vanuit deze bibliotheek zullen we de methoden gebruiken die de kleur van individuele leds regelen en deze toepassen

- inclusief de bibliotheek:

#erbij betrekken

- de bibliotheek declareren

#define NEOPIXED_CONTROL_PIN 6

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

- initialiseren

#typisch binnen het setup-blok

void setup() { strip.begin(); # misschien wat andere dingen hier # …. }

- verlicht individuele pixels en pas vervolgens alle wijzigingen toe op de strip (render deze op een bepaalde manier)

# stel pixel 0 in om rood te zijn

strip.setPixelColor(0, strip. Color(255, 0, 0)); # stel pixel 1 in als groene strip.setPixelColor(1, strip. Color(0, 255, 0)); # stel pixel 2 in als blauwe strip.setPixelColor(2, strip. Color(0, 0 255)); strip.show();

2. APDS 9960-bewegingssensor

Vanuit deze bibliotheek zullen we de functie "lees gebaar" gebruiken. Deze functie kan onderscheid maken tussen links-rechts, omhoog-omlaag, dichtbij-veraf commando's. Er is hier een truc, we gaan de sensor niet continu vragen om het laatst waargenomen gebaar. Het bord heeft de mogelijkheid om via een interrupt te "pingen" dat er een gebaar is gevonden.

- neem de bibliotheek op, vergelijkbaar met de neopixel

- verklaar de bibliotheek de interrupt-pin en de interrupt-vlag

#define APDS9960_INT 2

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

- initialiseer de bibliotheek, meestal binnen de setup-functie

ongeldige setup()

{ # declareer de interrupt-pin als INPUT en koppel er een functie aan pinMode (APDS9960_INT, INPUT); attachInterrupt(0, interruptRoutine, FALLING); if (apds.init() && apds.enableGestureSensor(true)) { Serial.println ("APDS-9960 initialisatie voltooid"); } else { Serial.println("Er is iets misgegaan tijdens APDS-9960 init!"); } # initialiseer andere dingen misschien }

- definieer de interrupt-functie, hier stellen we alleen een vlag in

void interruptRoutine() {

isr_vlag = 1; }

- controleer binnen de lusfunctie regelmatig de vlag om te zien of een gebaar is gedetecteerd

lege lus()

{ # controleer de vlag if(isr_flag == 1) { # als de vlag is ingesteld, verwijder de interrupt, voer de noodzakelijke verwerking uit in de handleGesture() functie # en reset vervolgens de vlag en bevestig de interrupt opnieuw detachInterrupt(0); handvatGesture(); isr_vlag = 0; attachInterrupt(0, interruptRoutine, FALLING); } # hier misschien een andere code }

- definieer handleGesture() functie waar we om het laatste gebaar kunnen vragen

ongeldig handvatGesture() {

# als geen enkel gebaar beschikbaar is return, is dit alleen een veilige controle if (!apds.isGestureAvailable()) { return; } # leest het laatste gebaar, vergelijkt met de bekende en drukt een berichtschakelaar af (apds.readGesture()) { case DIR_UP: Serial.println("UP"); pauze; geval DIR_DOWN: Serial.println ("DOWN"); pauze; geval DIR_LEFT: Serial.println ("LEFT"); pauze; geval DIR_RIGHT: Serial.println ("RIGHT"); pauze; geval DIR_FAR: Serial.println ("FAR"); pauze; } }

Laten we nu de hele code in actie zien:

Dus ik heb de basis-API van de bewegingssensor en de neopixelring uitgelegd, laten we nu de dingen samenvoegen:

Het algoritme werkt als volgt:

- initialiseer de bibliotheken (zie de code hierboven)

- maak een array van led-intensiteiten genaamd "ledStates". Deze array zal 24 led-intensiteiten bevatten die op een aflopende manier zijn gerangschikt van 150 naar 2

- controleer in de hoofdlus of de interrupt-pin is gewijzigd. Zo ja, dan is het tijd om de animatie of kleur van de led te veranderen

- de functie "handleGesture()" controleert het laatste gebaar en roept de functie "toggleColor" aan voor OMHOOG - OMLAAG-gebaren of stelt een globale variabele "ledDirection" in voor LINKS - RECHTS-gebaren

- de functie "toggleColor()" verandert eenvoudig een globale variabele met de naam "colorSelection" met een van de waarden 0, 1, 2

- ook binnen de hoofdlusfunctie een andere functie genaamd "animateLeds();" wordt genoemd. Deze functie controleert of er 100 milliseconden zijn verstreken, en zo ja, roteert het de leds met de functie "rotateLeds()" en tekent ze vervolgens opnieuw

- de "rotateLeds()" zal de leds naar voren of naar achteren "draaien" met behulp van een andere array genaamd "intermediateLedStates".

Het rotatie-effect ziet er als volgt uit:

# na initialisatie

{150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # na rotatieLeds() heet {0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # nadat rotaryLeds() opnieuw wordt aangeroepen {0, 0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # enzovoort

Hiervoor maakt u eerst de nieuwe array en kopieert u de oude led-intensiteiten op de nieuwe posities (de positie verhogen of verlagen). Daarna overschrijft het de "ledStates" array met de "intermediateLedStates" zodat het proces na nog eens 100 milliseconden zal doorgaan.

#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_KEORBGIN +, NUM_LEDS, NEOPIXED_KEORBGIN +, NUM_LEDS, NEOPIXED_KEORBGIN +, N SparkFun_APDS9960 apds = SparkFun_APDS9960(); unsigned long lastLedChangeTime = 0; korte ledDirection = 0; korte kleurselectie = 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("Programma gestart"); strip.begin(); pinMode (APDS9960_INT, INPUT); attachInterrupt(0, interruptRoutine, FALLING); if (apds.init() && apds.enableGestureSensor(true)) { Serial.println ("APDS-9960 initialisatie voltooid"); } else { Serial.println("Er is iets misgegaan tijdens APDS-9960 init!"); } lastLedChangeTime = millis(); Serial.println("Init succesvol"); } void loop() {if(isr_flag == 1) { detachInterrupt(0); handvatGesture(); isr_vlag = 0; attachInterrupt(0, interruptRoutine, FALLING); } animerenLeds(); } void interruptRoutine() { isr_flag = 1; } /** * Dit verwerkt gebaren van de APDS9960-sensor * Omhoog en omlaag gebaren roepen de toggleColor-functie op * Links en rechts gebaren veranderen de led-animatie */ void handleGesture() { if (!apds.isGestureAvailable()) { return; } switch (apds.readGesture()) { case DIR_UP: Serial.println("UP"); toggleKleur(); pauze; geval DIR_DOWN: Serial.println ("DOWN"); toggleKleur(); pauze; geval DIR_LEFT: ledDirection = 1; Serial.println("LINKS"); pauze; geval DIR_RIGHT: ledDirection = -1; Serial.println("RECHTS"); pauze; geval DIR_FAR: ledDirection = 0; Serial.println("FAR"); pauze; } } /** * Huidige kleur leds wijzigen * Elke keer dat deze functie wordt aangeroepen, verandert de status van de leds */ void toggleColor() { if (colorSelection == 0) { colorSelection = 1; } else if (colorSelection == 1) { colorSelection = 2; } else { colorSelection = 0; } } /** * De animatie wordt uitgevoerd na LED_SPEED_STEP_INTERVAL millis * Eerst wordt de functie rotaryLeds aangeroepen, daarna worden de kleuren van de leds ingesteld met de strip api */ void animateLeds() { if (millis() - lastLedChangeTime < LED_SPEED_STEP_INTERVAL) { return; } roterenLeds(); for (int i=0; i <NUM_LEDS; i++) { strip.setPixelColor(i, getColor(ledStates)); strip.show(); } lastLedChangeTime = millis(); } /** * Met behulp van een secundaire array "intermediateLedStates", worden led-intensiteiten geanimeerd * Eerst worden de waarden van "ledStates" gekopieerd naar "intermediateLedStates", zoals zo * laten we de array "ledStates" {100, 80, 60, 0, 0, 0} en de ledDirection is 1 * dan nadat deze functie "ledStates" is genoemd, is de array {0, 100, 80, 60, 0, 0} een rotatie-effect simulerend */ void roterendeLeds() { 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; } } else { 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 intensity) { switch (colorSelection) { case 0: return strip. Color (intensiteit, 0, 0); geval 1: retourstrook. Kleur (0, intensiteit, 0); standaard: retourstrook. Kleur (0, 0, intensiteit); } }

Ik hoop dat je dit leuk vond, je kunt de opmerkingensectie gebruiken om me vragen te stellen.