DIY Wizard Walking Staff Kit – Arduino, LED-strip, spanningsregelaar en meer

Onderdelen en benodigdheden

Apps en online diensten

• Arduino IDE

Over dit project

Dit project gebruikt de Arduino 101, een batterij en een LED-strip om een gebaren-gestuurde tovenaarswandelstaf te maken. We definiëren drie verschillende lichtweergave "spellen" die je kunt oproepen door de staf in een van drie gebaren te bewegen.

Techniek

De code gebruikt de Inertial Measurement Unit (IMU) in de Arduino 101 om G-krachten te lezen, maar gebruikt niet de Pattern Matching Engine (voor een voorbeeld met PME, bekijk Kitty Yeung's PME-project). In plaats daarvan telt deze code snelle impulsjes in de X-, Y- en Z-richting en roept spellen aan wanneer je een bepaalde combinatie in korte tijd uitvoert.

Spellen uitspreken

Twee snelle vertikale tikken start een spel, daarna kun je de staf scherp voorwaarts, links/rechts bewegen, of een derde keer tikken om een van de drie spellen te selecteren, en een laatste tik om het spel te activeren.

Visuele feedback

Om je te helpen begrijpen waar je in je gebaar bent, bevat de voorbeeldcode visuele feedback van de LED-strip. Wanneer je eerst een dubbele tik uitvoert, knipperen de lichten snel wit, wat aangeeft dat een spel is gestart. Je krijgt visuele feedback voor elke stap, zodat je weet welk spel geselecteerd wordt.

Spellen uitspreken (in detail)

Houd de staf met de Arduino 101 naar je toe. Tik eerst twee keer op de grond (voorzichtig!) of doe twee snelle verticale pulsen in de lucht. Wanneer je de witte flits ziet, beweeg de staf scherp voor- of achterwaarts voor Spel 1, kantel de staf links of rechts voor Spel 2, of beweeg verticaal een derde keer voor Spel 3. Wanneer een spel geselecteerd is, zullen de lichten vast groen (spel 1), blauw (spel 2) of rood (spel 3) branden. Zodra de lichten vast branden, roep het spel aan met een laatste verticale tik. De lichten zullen schitteren en knipperen in de geselecteerde kleur.

Gebaren zijn tijdsgevoelig! Je hebt slechts 1 seconde tussen elke stap in een gebaar of het spel reset. Dat betekent dat als je een fout maakt of het verkeerde spel selecteert, je gewoon een seconde kunt wachten en opnieuw kunt beginnen. Nauwkeurig spellen oproepen is een beetje tricky om onder de knie te krijgen, maar het goede nieuws is dat spellen niet per ongeluk worden aangeroepen wanneer je gewoon met de staf rondloopt.

De elektronica bouwen

Dit is eigenlijk gewoon een Arduino 101, een batterij en een strip NeoPixel LEDs.

Er zijn verschillende manieren om de voeding te configureren. De snelste zou zijn een 9V-batterij gebruiken en de LEDs rechtstreeks van de Arduino 101 laten draaien - maar de batterijduur zou erg kort zijn. Je kunt ook een LiPo-batterij gebruiken om vermogen/gewicht te maximaliseren voor een meer "professionele" build - maar je hebt een veilige manier nodig om de batterij op te laden. Voor mij is een goed evenwicht tussen batterijduur en simpliciteit om 3 AA-batterijen en een $4 spanningsregelaar te gebruiken. Dit is dezelfde elektronica-opstelling als in de Shadow Theater en Kaleidoscope Infinity Mirror.

Stap 1

Haal de eindconnector van je LED-strip los door ongeveer 1 cm van het einde van de lichten af te knippen. Ontmantel de draadeinden.

Stap 2

Haal de gebogen header-pinnen los die bij je spanningsregelaar zaten, en soldeer er twee aan de uiteinden van de groene en gele draad. Hierdoor kun je ze gemakkelijk in de pinnen van de Arduino 101 steken.

Stap 3

Soldeer nu de rode draad aan de VIN-klem van de spanningsregelaar, en soldeer twee rechte headers in de GND- en VOUT-pinnen zoals getoond.

Stap 4

Sluit nu de barrel jack adapters aan. Ontmantel eerst de uiteinden van de draden van je batterijhouder, monteer ze in de klemmen van de mannelijke barrel jack en draai ze vast met een schroevendraaier. ROOD gaat naar de (+) klem, ZWART naar de (-) klem.

Sluit vervolgens de vrouwelijke barrel jack adapter aan op de losse draden van het begin van de LED-strip. GEEL gaat naar de (-) klem, en ROOD naar de (+).

Stap 5

Sluit nu je harness aan op de Arduino 101. De GROENE draad gaat naar PIN 6, de GELE draad gaat naar de GND-pin bij #13. Met de twee header-pinnen op de spanningsregelaar: GND gaat naar GND en VOUT gaat naar de "VIN"-pin op de Arduino 101. Doe dit niet verkeerd! Achterstevoren insteken leidt tot geur en brandsporen. Ik weet het.

De voorbeeldcode uploaden

Stap 1

Met de batterijhouder uitgezet, gebruik een USB-kabel om je Arduino 101 met een computer te verbinden, en upload de bijgevoegde voorbeeldcode met de Arduino IDE.

Als je nog nooit een Arduino 101 hebt geprogrammeerd, zijn er geweldige instructies op de Arduino-website hier: https://www.arduino.cc/en/Guide/Arduino101

Zodra de voorbeeldcode succesvol is geladen, kun je de USB loskoppelen, en de code testen door de batterijhouder aan te zetten en een paar van de spelgebaren uit te proberen met de USB-poort op de Arduino 101 naar beneden gericht, en de pinnen naar je toe. Probeer het bord vier keer verticaal te bewegen om het Rode Spel aan te roepen.

Code-discussie:

(Als je de voorbeeldcode gewoon wilt gebruiken zoals hij is, kun je direct doorgaan naar De staf bouwen.)

De voorbeeldcode gebruikt de schokdetectie-mogelijkheid van de Arduino 101 om schokken te tellen, terwijl een timer loopt die de schoktelling na een korte tijd zonder nieuwe schokken reset. Als je de juiste combinatie haalt voordat de timer verloopt, wordt een "spel"-functie aangeroepen.

Omdat een stevige tik op de daadwerkelijk de initiële schok plus verschillende "ruis"-schokken van de trillingen in de staf registreert, probeert de eerste code in loop de dominante impuls uit elke batch schokken te vinden en deze simpel te categoriseren als verticaal, links/rechts, of voor/achter. Ik gebruik een variabele genaamd "gesture" om elke dominante impuls vast te houden: 1 = verticale impuls, 2 = voor/achter impuls, 3 = links/rechts impuls.

Om combinaties bij te houden, gebruikt de code een "switch"-statement, en beweegt erdoor heen naarmate gesturen zich opstapelen. Het is een beetje als een "kies je eigen avontuur"-boek, waar elke stap zegt: "als de volgende impuls links/rechts is, ga naar stap 2, als de timer verlopen is, ga terug naar nul."

Spellen:

Hier kun je eenvoudig wijzigen wat elk spel doet. Deze draaien momenteel gewoon "theater-chase" voorbeeldcode in verschillende kleuren. Je kunt er eenvoudig meer aan toevoegen, de kleuren veranderen, of je eigen lichtfunctie hier schrijven. De eerste drie variabelen in de theaterChase-functie zijn waarden voor rood, groen en blauw. Het laatste getal is de snelheid (hoger getal = langzamer).

/////////////////////////////////////////////////spells//////////////////////
void tapspell() {
    ///rode theaterlichten
    theaterChase(strip.Color(127, 20, 0), 20);
    theaterChase(strip.Color(127, 20, 50), 55);
    strip.show();
}
void leftspell() {
    theaterChase(strip.Color(0, 0, 100), 20);
    theaterChase(strip.Color(0, 30, 120), 75);
    strip.show();
}
void forwardspell() {
    theaterChase(strip.Color(0, 127, 0), 30);
    theaterChase(strip.Color(0, 127, 90), 55);
    strip.show();
}

De staf bouwen

Er is veel ruimte voor creativiteit hier! Ik focussen op de basistechnische build, maar veel plezier met het maken van een unieke staf. Lichtdiffusoren zoals tul, papier, of een plastic fles over de LEDs kunnen heel coole lichtweergaven maken!

Stap 1: Zoek een wandelstok/staf

Je kunt een bezemstang, sprinklerpijp, of een natuurlijke tak gebruiken. Michael's craftwinkels verkopen ook leuke. (In de tak-sectie - echt.) Ik wil graag een stuk omwikkelen met sporttape om een schoon werkterrein voor de elektronica te hebben, maar dat is optioneel.

Zet een paar rubberen banden op de staf om het makkelijker te maken om dingen te bevestigen.

Stap 2: Plaats de Arduino 101 op de staf met de USB-poort naar beneden

Gebruik een rubberen band om de Arduino 101 op zijn plek te houden.

Stap 3: Gebruik rubberen banden aan beide uiteinden om de LEDs te omwikkelen

Stap 4: Omwikkel sporttape om de Arduino 101 en batterijhouder te bevestigen

Zorg dat de aan/uit-schakelaar op de batterijhouder bereikbaar blijft. Je wilt de batterijhouder stevig bevestigen voor ritselingen/tikken, maar onthoud dat je de batterijen uiteindelijk moet vervangen.

Stap 5: Diffuseer de LED-lichten en versier

Code

Wizard Walking Staff Voorbeeldcode

/* Copyright (c) 2016 Intel Corporation. All rights reserved. See license notice at end of file. */
/* Arduino 101 "Wizard's Walking Staff." This code uses the Adafruit Neopixel library.
Library installation instructions here: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-installation
Make sure you have the latest Intel Curie Core installed. For more info, visit https://www.arduino.cc/en/Guide/Arduino101 */
#include "CurieIMU.h"
#include <Adafruit_NeoPixel.h>
#define PIN 6 //// what pin are the NeoPixels connected to?
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60 , PIN, NEO_GRB + NEO_KHZ800); /// the strip is 60 pixels long.
int tr = 0; //Some variables to hold color target and color current for smoothing...
int tg = 0;
int tb = 0;
int r = 0;
int g = 0;
int b = 0;
long int globaltimer = 0; /// timers to keep track of gestures vs time...for things like "if timer hasn't passed 0.5sec, AND there's two taps, then..."
long int gesturetimer = 0;
long int ledtimer = 0;
int fade = 10; /// how quickly lights fade. Used for smoothing
int tap = 0; //counter for vertical impulses
int lr = 0; //counter for left/right impulses
int fb = 0; //counter for forward/back impulses
int gesture = 0; // int state = 0; /// for our switch case... this will keep track of each movement in a series.

void setup() {
    // put your setup code here, to run once:
    //Serial.begin(9600);
    globaltimer = millis(); // start timekeepers at current time
    gesturetimer = millis();
    ledtimer = millis();
    /* Initialise the IMU */
    CurieIMU.begin();
    CurieIMU.attachInterrupt(eventCallback);
    /* Enable Shock Detection */
    CurieIMU.setDetectionThreshold(CURIE_IMU_SHOCK, 1500); // 1.5g = 1500 mg
    CurieIMU.setDetectionDuration(CURIE_IMU_SHOCK, 50); // milliseconds of spike required to call interrupt
    CurieIMU.interrupts(CURIE_IMU_SHOCK);
    strip.begin(); // intialize neopixel strip
    strip.show(); // Initialize all pixels to 'off'
}

void loop() {
    // put your main code here, to run repeatedly:
    ////basic filter- the IMU registers multiple shocks from rebound and counteraction. This tries to capture the dominant shock in each gesture.
    if (millis() - globaltimer > 170) {
        /// this tries to find the dominant axis of movement for each shock.. Compares the sum of tap, left-right, and front-back movements, and picks the largest.
        if ((tap > lr) && (tap > fb)) {
            Serial.println("tap");
            gesture = 1;
            tap = 0; lr = 0; fb = 0;
            //// reset values after a movement is classified.
        } else if ((lr > fb) && (lr > tap)) {
            Serial.println("lr");
            gesture = 2;
            tap = 0; lr = 0; fb = 0;
        } else if ((fb > lr) || (fb > tap)) {
            Serial.println("fb");
            gesture = 3;
            tap = 0; lr = 0; fb = 0;
        }
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if (millis() - globaltimer > 1000) {
        /////timeout reset
        globaltimer = millis() - 170;
        tr = 0; tg = 0; tb = 0;
        state = 0;
    }
    if (millis() - gesturetimer > 1000) {
        gesturetimer = millis() - 350;
        tr = 0; tg = 0; tb = 0;
        state = 0;
    }
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    switch (state) {
        // This tracks gestures
        case 0: {
            /// no gestures recorded yet... listen for tap. If there's one, go to case 1.
            if (millis() - gesturetimer > 350) {
                if (gesture == 1) {
                    state = 1;
                    gesture = 0;
                    gesturetimer = millis();
                }
            }
            break;
        }
        case 1: {
            ///// one tap recorded. If a second tap happens, play a quick flash then go to step 2.
            if (millis() - gesturetimer > 350) {
                if (gesture == 1) {
                    r = 10; g = 10; b = 10; ///feedback flash
                    state = 2;
                    gesture = 0;
                    gesturetimer = millis();
                }
            }
            break;
        }
        case 2: {
            ///////Switch point - two taps recorded. The three spells diverge here based on the next gesture.
            if (millis() - gesturetimer > 350) {
                if (gesture == 1) { state = 3; gesture = 0; gesturetimer = millis(); }
                if (gesture == 2) { state = 4; gesture = 0; gesturetimer = millis(); }
                if (gesture == 3) { state = 5; gesture = 0; gesturetimer = millis(); }
            }
            break;
        }
        case 3: {
            //// three taps recorded... we're in the tap spell, turn the staff red and listen for the final "tap" to set off the spell.
            tr = 20; tg = 0; tb = 0;
            globaltimer = millis() - 250;
            if (millis() - gesturetimer > 350) {
                if (gesture == 1) {
                    state = 0;
                    Serial.println("tapspell!");
                    tapspell();
                }
            }
            break;
        }
        case 4: {
            ///// two taps and a L or R recorded... we're in the leftspell, turn the staff blue and listen for the final "tap" to set off the spell.
            tr = 0; tg = 0; tb = 20;
            globaltimer = millis() - 250;
            if (millis() - gesturetimer > 350) {
                if (gesture == 1) {
                    state = 0;
                    Serial.println("leftspell!");
                    leftspell();
                }
            }
            break;
        }
        case 5: {
            ///// two taps and a forward or back recorded... we're in the forwardspell, turn the staff green and listen for the final "tap" to set off the spell.
            tr = 0; tg = 20; tb = 0;
            globaltimer = millis() - 250;
            if (millis() - gesturetimer > 350) {
                if (gesture == 1) {
                    state = 0;
                    Serial.println("forwardspell!");
                    forwardspell();
                }
            }
            break;
        }
        default: { break; }
    }
    //Serial.println(tr);
    if (millis() - ledtimer > fade) {
        /// only do this next step periodically every (fade value) milliseconds. Unlike the "delay()" function, this allows other things to happen in the program in between updates.
        /// color smoothing. Actual color moves toward target color... If target is more than current, move up, if less, move down.
        if (tr > r + 1) { r++; }
        if (tg > g + 1) { g++; }
        if (tb > b + 1) { b++; }
        if (tr < r) { r--; }
        if (tg < g) { g--; }
        if (tb < b) { b--; }
        //turn all the LEDS to the current r, g, b values.
        for (int i = 0; i < strip.numPixels(); i++) {
            strip.setPixelColor(i, r, g, b);
        }
        strip.show();
        ledtimer = millis();
    }
}

///////////When a shock is detected, the following code interrupts the loop.
static void eventCallback(void) {
    if (CurieIMU.getInterruptStatus(CURIE_IMU_SHOCK)) {
        if (CurieIMU.shockDetected(X_AXIS, POSITIVE)) { tap++; globaltimer = millis(); }
        if (CurieIMU.shockDetected(X_AXIS, NEGATIVE)) { tap++; globaltimer = millis(); }
        if (CurieIMU.shockDetected(Y_AXIS, POSITIVE)) { lr++; globaltimer = millis(); }
        if (CurieIMU.shockDetected(Y_AXIS, NEGATIVE)) { lr++; globaltimer = millis(); }
        if (CurieIMU.shockDetected(Z_AXIS, POSITIVE)) { fb++; globaltimer = millis(); }
        if (CurieIMU.shockDetected(Z_AXIS, NEGATIVE)) { fb++; globaltimer = millis(); }
    }
}

/////////////////////////////////////////////////spells//////////////////////
void tapspell() {
    ///red theatre lights
    theaterChase(strip.Color(127, 20, 0), 20);
    theaterChase(strip.Color(127, 20, 50), 55);
    strip.show();
}
void leftspell() {
    theaterChase(strip.Color(0, 0, 100), 20);
    theaterChase(strip.Color(0, 30, 120), 75);
    strip.show();
}
void forwardspell() {
    theaterChase(strip.Color(0, 127, 0), 30);
    theaterChase(strip.Color(0, 127, 90), 55);
    strip.show();
}

////////////////Spell functions for lights////////// From the Adafruit Neopixel Strandtest Example
//Theatre-style crawling lights.
void theaterChase(uint32_t c, uint8_t wait) {
    for (int j = 0; j < 10; j++) { //do 10 cycles of chasing
        for (int q = 0; q < 3; q++) {
            for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
                strip.setPixelColor(i + q, c); //turn every third pixel on
            }
            strip.show();
            delay(wait);
            for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
                strip.setPixelColor(i + q, 0); //turn every third pixel off
            }
        }
    }
}

////////////////////////////////////////////////////////////////////////////////////////////
/* This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */