Stap 15: Mijn volledige capaciteit Code
/ * ik deed mijn best om te bevestigen de verminking van mijn opmaak dat gebeurde toen ik mijn code in de pagina geplakt. Sommige dingen had zelfs zijn gewist/niet geplakt!
Zou het verstandig om te controleren en ervoor te zorgen dat er iets belangrijks was niet uitgecommentarieerd zodra je het in de Arduino omgeving.
Origineel compileert prima, commentaar als het broken.* /
int sensor1 = A2; genaaide naar mijn... aanwijzer vinger
int sensor2 = A3; //middle int sensor3 = A4; int sensor4 ring = A5; Pinky
#include / / yaaap, wilt worden met inbegrip van deze. Zie hun uberguide voor hoe te installeren in uw bibliotheek van de arduino.
Het is een relatief eenvoudig ~ 3 stapproces, de moeite waard. De bestanden en instructies zijn op de volgende website:
https://Learn.adafruit.com/adafruit-neopixel-uber...
Dan klik op de banner van bestand "Schets" en selecteer bestand toevoegen in het menu om te navigeren naar waar de .h bestand wordt opgeslagen als u wilt een tabblad toevoegen aan dit project
statische int PIN = 10; Als u dit bent vergeten waar het PIN zegt daar beneden gaat de compiler te gek te krijgen.
Het nummer is de naam van de pin op uw lilypad dat de gegevens worden verzonden uit.
het volgende is rechtstreeks uit het voorbeeldbestand voor de "strandtest"
Parameter 1 = aantal pixels in strip
Parameter 2 = pin-nummer (de meeste zijn geldig)
Parameter 3 = pixel type vlaggen, wens samen toevoegen: (links uit de extra info, betekent weinig voor mij) Adafruit_NeoPixel strip = Adafruit_NeoPixel (15, PIN, NEO_GRB + NEO_KHZ800);
Ik heb 15 pixels, dus dat nummer
/******************************************************************** *********************************************************************
* meer instellen *
* *
********************************************************************/
VOID Setup {}
voor verlichting:
strip.begin();
strip.show();
"Initialiseren van alle pixels op 'off'"
Initialiseer seriële communicatie met 9600 bits per seconde:
pinMode (sensor1, INPUT); wordt de aanwijzer brei potentiometer pin ingesteld op INPUT
digitalWrite (sensor1, hoge); //initializes de sensor
pinMode (sensor2, INPUT); sets middelste brei potentiometer van pin aan INPUT
digitalWrite (sensor2, hoge); initialiseert de sensor
pinMode (sensor3, INPUT); sets ring brei potentiometer van folie pin om INPUT
digitalWrite (sensor3, hoge); initialiseert de sensor
pinMode (sensor4, INPUT); pinky brei potentiometer van pin ingesteld op INPUT
digitalWrite (sensor4, hoge); initialiseert de sensor
Serial.begin(9600); }
/******************************************************************** *********************************************************************
* *
* belangrijkste functie *
* *
********************************************************************* ********************************************************************/
void loop {}
int midden = 8; middelste licht
int rechts = 15; rechterkant licht (hoogste LED adres)
int links = 1; linkereinde licht (laagste LED adres)
Lees de input op analoge pin:
3.3 V = 1024
0 V is 0
"SV" kort voor 'sensor waarde'
int SV1 = analogRead(sensor1); 300-400 lo 890-950 hi
int SV2 = analogRead(sensor2); 650-700 lo 900-1015 Hallo
int SV3 = analogRead(sensor3); min max 650-700 avg avg 1000
int SV4 = analogRead(sensor4); min 530 max 1024 - avg Hallo 950 avg lo 650ish
Als overvloeien kleuren waren de wens, kon 0-250 toewijzen aan de 300-950 als de waarde van één RGB per vinger zou cool pinky worden enkele willekeurige weird mengen RGB vergelijkingen met behulp van de toegewezen waarde. eh.
/ * //uncomment deze sectie om gebruik van de seriële afdrukfunctie en krijg je eigen vinger pads bereiken.
de waarde die u leest uitprinten:
Serial.Print ("waarde 1 =");
Serial.Print(sensorValue1);
Serial.Print ("waarde 2 =");
Serial.Print(sensorValue2);
Serial.Print ("waarde 3 =");
Serial.Print(sensorValue3);
Serial.Print ("waarde 4 =");
Serial.println(sensorValue4);
*/
/********************************************************************
* Als/dan reactie *
********************************************************************/
max antwoord reeks op 950, ik denk dat dit moet houden ze van alle reagerende TRUE.
voor nu, zal ik moeten hoog/laag bepalen... schieten, aantal herhalingen geluiden goed. Kleur ook?
uint16_t herhaalt = 2; geïnitialiseerd op twee >> gooi nummer in functieaanroep!
AANWIJZER vinger---> rechts afslaan
300-400 lo 890-950 hi
Als ((SV1 < = 950) & & (SV1 > = 650))
koos van 650 sinds haar over het midden van mijn "lage high end" en hogere "laag" lezingen.
{
Right_then (strip. Color(250,140,0),4,Middle,right); kunt wijzigen kleur hier RGB
}
Als ((SV1 < = 649) & & (SV1 > = 0))
{Right_then (strip. Color(250,0,0),8,Middle,right); }
MIDDELVINGER---> links
650-700 lo 900-1015 Hallo
Als ((SV2 < = 950) & & (SV2 > = 775))
{Left_I_go (strip. Color(250,140,0), 4, midden, links); }
Als ((SV2 < = 774) & & (SV2 > = 0))
{Left_I_go (strip. Color(250,0,0), 8, midden, links); }
RINGVINGER---> schattig knipperen
min max 650-700 avg avg 1000
Als ((SV3 < = 950) & & (SV3 > = 840))
{Notice_me_Cute (strip. Color(0,0,150), 3, links, midden, rechts); blauw}
Als ((SV3 < = 839) & & (SV3 > = 0)) //not een groot verschil lager nauwkeurigheid == == ik ben het bijhouden van de herhalingen korte om beurten kunnen worden gesignaleerd.
{Notice_me_Cute (strip. Color(127,255,0), 5, links, midden, rechts); Lime groen}
PINKY---> meh
min 530 max 1024 - avg Hallo 950 avg lo 650ish 650 + (950-650) / 2 = middelste waarde ik kiezen
Als ((SV4 < = 960) & & (SV4 > = 800))
{dualFade (links, rechts);}
Als ((SV4 < = 799) & & (SV4 > = 0))
{dualFade2 (links, rechts);}
/********************************************************************
* knipperen van de standaard *
********************************************************************
/ kan later, proberen om er "schattig" degene door het hebben van een generieke tegen, zeggend teller ++; elke lus,
en met behulp van een % 8 te lastig over het maken van een andere variabele verandering tussen 1-7
.. .en wisselen tussen + en -? wellicht een derde variabele bestaande de "als %8 == 0" om te gaan met %2 en hebben een geneste als verklaring over +/-
'merken mij'
for (int i = left; ik > = rechts; i ++)
{//strip.setPixelColor(pixel#,(R,G,B) gedefinieerd in functie feed)
strip.setPixelColor(i,255,215,0); "goud" kleur
strip.show();
}
delay(300);
zetten buiten haakjes om te proberen en de lichten schakelen op "all at once" dan verblijf voor een beetje
nu het uitschakelen
for (int i = rechts; ik > = links; ik--)
{/ / strip.setPixelColor(pixel#,R,G,B);
strip.setPixelColor(i,0,0,0);
strip.show();
}
delay(300);
vertraging tussen leest/knippert voor stabiliteit (was 75 voor de seriële afdrukken.)
> <> <> <> <> <
}
/********************************************************************
* EINDE van belangrijkste functie *
********************************************************************
********************************************************************
* *
* DE SENSOR WERKT!!! *
* *
* Ik hou van aanroepen van functies, zijn dus... SCHOON!!! *
* *
* Nodig: blink verliet de helft (1-8 pixels... of is dat 0-7?) *
* knipperen rechterhelft (pixels 8-15... of 7-14)? *
* "Let me" knipperen (rainbow, zeker) *
* voor de lol: regenboog wipe *
*********************************************************************
* zijn mijn leds aangepakt
[1] [2 [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] [15]
of [0] [1] [2 [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14]?
Verandert mijn interne for() iteraties *
********************************************************************
* knipperen links *
********************************************************************/
VOID Left_I_go (uint32_t kleur uint16_t herhaalt, int midden, int links)
op basis van colorWipe in strandtest. Hier is hoe de "uint32_t c" heette in 'main()' 50 werd het "wachten"!
/ * colorWipe (strip. Color(255, 0, 0), 50); Rood
colorWipe (strip. Color(0, 255, 0), 50); / / groen
colorWipe (strip. Color(0, 0, 255), 50); / / blauwe * /
strip. Color(_,_,_),repeats,Middle,left)
{//variables
uint8_t wachten = 20;
uint16_t i;
uint16_t z; 'z' ziet er anders uit dan 'ik'
wil het knipperen van een paar keer, dus maken een geneste for-lus
voor (z = 0; z < = herhaalt; z ++)
{voor (ik = midden; ik > = links; ik--)
{
strip.setPixelColor(i,color);
strip.show();
delay(wait); }
een ander vertraging hen om op te houden voor een beetje
delay(100);
nu het uitschakelen
> <> <
voor (ik = midden; ik > = links; ik--)
{/ / strip.setPixelColor(pixel#,R,G,B);
strip.setPixelColor(i,0,0,0);
strip.show();
}
delay(100);
> <> <
}
}
/********************************************************************
* knipperen rechts *
********************************************************************/
VOID Right_then (uint32_t kleur uint16_t herhaalt, int midden, int recht
) {/ / / strip. Color(_,_,_),repeats,Middle,right)
variabelen
uint8_t wachten = 20; Maak korte
uint16_t i;
uint16_t z;
wil het knipperen van een paar keer, dus maken een geneste for-lus
voor (z = 0; z < = herhaalt; z ++)
{voor (ik = midden; ik < = rechts; i ++)
{
strip.setPixelColor(i,color);
strip.show();
delay(wait);
}
een ander vertraging hen om op te houden voor een beetje
delay(100);
nu het uitschakelen
> <> <
voor (ik = midden; ik < = rechts; i ++) //note hoe ik bladerde > op < en--++
{
strip.setPixelColor(i,0,0,0);
strip.show();
}
delay(100); }
}
/********************************************************************
* leuke stoten knipperen *
********************************************************************/
HM. er een manier om, Umm is... misschien word. instellen als de standaardbrowser knipperen deel van de void loop, zoals zet voordat elke sensor controleert, moet het snel genoeg, recht? een vertraging kan toevoegen. Ja! Ik zal gewoon maken dit een leuke decoratieve versie, bounching van de twee lichten off van elkaar in het midden en uit de uiteinden...
VOID Notice_me_Cute (uint32_t kleur uint16_t herhaalt, int verliet, int midden, int recht)
{/ / strip. Color(_,_,_),repeats,left,Middle,right)
strip.setPixelColor(pixel#,R,G,B);
variabelen
uint8_t wachten = 50; een beetje trager dan 20 voor het draaien
uint16_t i;
uint16_t z;
voor (z = 0; z < = herhaalt; z ++)
{
in- en uitschakelen midden licht instellen
strip.setPixelColor(middle,color);
strip.show();
delay(wait);
strip.setPixelColor(middle,0,0,0);
strip.show();
nu voor de splitsing
voor (ik = 1; ik
{
strip.setPixelColor(middle-i,color); gaat links van centrum
strip.setPixelColor(middle+i,color); gaat vanaf centrum
strip.show(); aangetoond dat samen?
delay(wait);
Sinds 'one at a time' nodig uit te schakelen verlichting binnen for-lus
strip.setPixelColor(middle-i,0,0,0);
strip.setPixelColor(middle+i,0,0,0);
strip.show();
}
nu om terug te gaan omhoog naar het midden
controle voor een paar sensor input hier verstandig zou zijn als ik wil het herhalende veel... maar ik dunno als thats mogelijk/hoe te
voor (ik = 1; ik; ik--) //did (midden-1) omdat ik niet wil de randen knippert twee keer, ze zijn hit zodra wanneer al de rest zijn gegaan tweemaal in een cyclus.
{
strip.setPixelColor(middle-i,color); Dit moet recht gaan van links
strip.setPixelColor(middle+i,color); en deze links van rechts
strip.show();
delay(wait);
strip.setPixelColor(middle-i,0,0,0);
strip.setPixelColor(middle+i,0,0,0);
strip.show(); }
}
}
/********************************************************************
* dualFade (meh!) *
4e optie zou cool om te koppelen aan geluid of iets anders in plaats daarvan.
********************************************************************
/ iets te werpen op de pinky, aangezien ik niet de regenboog krijgen werkt in de strandtest te werken.
VOID dualFade (int verliet, int recht)
{
voor (int i = 0; ik < 255; i = i + 1)
{
voor (int k = left; k < = rechts; k ++)
{
int kloof = k 2 %;
Als (verdelen == 0)
strip.setPixelColor (k, ik, 0, 255-i);
anders
strip.setPixelColor (k, 0, i, 255-i);
delay(10);
strip.show(); }
}
}
/********************************************************************
* meh 2 *
********************************************************************
/ void dualFade2 (int-links, int)
{voor (int i = 0; ik < 255; i = i + 1) {}
voor (int k = left; k < = rechts; k ++)
{int kloof = k 2 %;
Als (verdelen == 0)
strip.setPixelColor (k, i, 255-i, 0);
anders
strip.setPixelColor (k, 0, 255-i, i);
delay(10);
strip.show();
}
}
}
