Blinker hängslen (15 / 15 steg)

Steg 15: Min full kapacitet kod

/ * jag gjorde mitt bästa att fixa stympningen av min formatering som hände när jag klistrade in min kod i sidan. Vissa saker hade även rensat/inte klistrats!

Skulle vara klokt att kontrollera och att något viktigt inte var kommenteras ut när du får det i Arduino-miljö.

Original sammanställer bra, kommentar om det är broken.* /

int sensor1 = A2; sytt till min... pekaren finger

int sensor2 = A3; //middle int sensor3 = A4; Ring int sensor4 = A5; Pinky

#include / / yaaap, vill inklusive detta. se deras uberguide för hur man installerar det till arduino-biblioteket.

Det är en relativt lätt ~ 3 steg, värt det. Filer och instruktioner finns på följande webbplats:

https://learn.adafruit.com/adafruit-neopixel-uber...

Klicka sedan på filen bannern "Skiss" och välj Lägg till fil i menyn Navigera till där filen .h sparas för att lägga till dess flik till detta projekt

statisk int PIN = 10; Om du glömmer detta, där det står PIN där nere kommer att arg kompilatorn.

Numret är namnet på stiftet på din lilypad som data skickas från.

Följande är raka från exempelfilen som "strandtest"

Parametern 1 = antal pixlar i remsa

Parameter 2 = pin-kod (de flesta är giltig)

Parameter 3 = pixel typ flaggor, Lägg ihop som behövs: (vänster ut extra info, betyder lite för mig) Adafruit_NeoPixel strip = Adafruit_NeoPixel (15, PIN, NEO_GRB + NEO_KHZ800);

Jag har 15 pixlar, således det numret

/******************************************************************** *********************************************************************

* upprätta mer *

* *

********************************************************************/

void setup() {

Lights:

Strip.BEGIN();

Strip.show();

"Initiera alla pixlar till"off""

initiera seriell kommunikation på 9600 bitar per sekund:

pinMode (sensor1, ingång); sätter pekaren sticka potentiometer pin till INPUT

digitalWrite (sensor1, hög); //initializes sensorn

pinMode (sensor2, ingång); uppsättningar mellersta sticka potentiometer stift till INPUT

digitalWrite (sensor2, hög); initierar sensorn

pinMode (sensor3, ingång); uppsättningar ring sticka potentiometer's folie stift till INPUT

digitalWrite (sensor3, hög); initierar sensorn

pinMode (sensor4, ingång); anger pinky sticka potentiometer pin till INPUT

digitalWrite (sensor4, hög); initierar sensorn

Serial.BEGIN(9600); }

/******************************************************************** *********************************************************************

* *

* Huvudfunktionen *

* *

********************************************************************* ********************************************************************/

void loop() {

int mitten = 8. mitt ljus

int höger = 15. till höger ljus (högsta LED adress)

int vänster = 1; vänster ljus (lägsta LED adress)

Läs input på analoga stift:

3.3 V är 1024

0 V är 0

"SV" kort för "sensor värde"

int SV1 = analogRead(sensor1); 300-400 lo 890-950 Hej

int SV2 = analogRead(sensor2); 650-700 lo 900-1015 Hej

int SV3 = analogRead(sensor3); min avg 650-700 max avg 1000

int SV4 = analogRead(sensor4); min 530 max 1024 - avg Hej 950 avg lo 650ish

Om blanda färger var en önskan, kunde mappa 0-250 till 300-950 som värdet av en RGB per finger skulle vara cool pinky några slumpmässiga weird blanda RGB ekvationer med hjälp av mappade värdet. eh.

/ * //uncomment detta avsnitt om du vill använda följetong utskriftsfunktionen och få ditt eget finger pads spänner.

skriva ut värdet du läsa:

Serial.Print ("värde 1 =");

Serial.Print(sensorValue1);

Serial.Print ("värde 2 =");

Serial.Print(sensorValue2);

Serial.Print ("värde 3 =");

Serial.Print(sensorValue3);

Serial.Print ("värde 4 =");

Serial.println(sensorValue4);

*/

/********************************************************************

IF/THEN svar *

********************************************************************/

Ange max svar på 950, jag tror att detta bör hålla dem från alla svarar sanna.

för nu, kommer att jag ha hög/låg bestämmer... shoot, antal repetitioner låter bra. Färg också?

uint16_t upprepas = 2; initieras på två >> bara kasta nummer i funktionsanropet!

PEKAREN FINGER---> sväng höger

300-400 lo 890-950 Hej

om ((SV1 < = 950) & & (SV1 > = 650))

valde 650 sedan dess omkring mitten av min "låga high end" och högre "låg" avläsningar.

{

Right_then (remsa. Color(250,140,0),4,Middle,Right); kan ändra färg här RGB

}

om ((SV1 < = 649) & & (SV1 > = 0))

{Right_then (remsa. Color(250,0,0),8,Middle,Right); }

LÅNGFINGRET---> sväng vänster

650-700 lo 900-1015 Hej

om ((SV2 < = 950) & & (SV2 > = 775))

{Left_I_go (remsa. Color(250,140,0), 4, mitten, vänster); }

om ((SV2 < = 774) & & (SV2 > = 0))

{Left_I_go (remsa. Color(250,0,0), 8, mitten, vänster); }

RINGFINGRET---> söt blink

min avg 650-700 max avg 1000

om ((SV3 < = 950) & & (SV3 > = 840))

{Notice_me_Cute (remsa. Color(0,0,150), 3, vänster, mitten, höger); blå}

om ((SV3 < = 839) & & (SV3 > = 0)) //not stor skillnad == lägre noggrannhet == jag håller upprepar kort för att säkerställa svängar kan signaleras

{Notice_me_Cute (remsa. Color(127,255,0), 5, vänster, mitten, höger); Limegrön}

PINKY---> meh

min 530 max 1024 - avg Hej 950 avg lo 650ish 650 + (950-650) / 2 = mellersta värde jag väljer

om ((SV4 < = 960) & & (SV4 > = 800))

{dualFade (vänster, höger);}

om ((SV4 < = 799) & & (SV4 > = 0))

{dualFade2 (vänster, höger);}

/********************************************************************

* standard blink *

********************************************************************

/ senare, kan försöka göra det den "söta" genom att ha en generisk räknare, säger counter ++; varje slinga,

och använda en % 8 vara knepigt om att göra en annan variabel förändring mellan 1-7

.. .och byta mellan + och -? kanske behöver en tredje variabel existerande i den "om %8 == 0" att gå %2 med och ha ett kapslat if uttalande om +/-

"att märka mig"

för (int jag = vänster; jag > = höger; i ++)

{//strip.setPixelColor(pixel#,(R,G,B) definierats i funktionen feed)

strip.setPixelColor(i,255,215,0); "guld" färg

Strip.show();

}

Delay(300);

sätta utanför parentes att försöka ha ljus aktiverar "på en gång" sedan vistelse på för lite

nu stänga av

för (int jag = höger; jag > = vänster; i--)

{/ / strip.setPixelColor(pixel#,R,G,B);

strip.setPixelColor(i,0,0,0);

Strip.show();

}

Delay(300);

fördröjning mellan läsningar/blinkar för stabilitet (var 75 för seriell utskriften.)

> <> <> <> <> <

}

/********************************************************************

* SLUTET av huvudfunktionen *

********************************************************************

********************************************************************

* *

* SENSOR FUNKTIONER! *

* *

* Jag älskar anropa funktioner, dess så... REN!!! *

* *

* Behövs: blink kvar hälften (1-8 pixlar... eller är det 0-7?) *

* blinka höger halva (pixlar 8-15... eller 7-14?) *

* "märker mig" blinka (rainbow, säker) *

* för kul: rainbow torka *

*********************************************************************

* är min lysdioder riktade

[1] [2 [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] [15]

eller [0] [1] [2 [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14]?

Kommer att ändra min inre for() iterationer *

********************************************************************

* blinka vänster *

********************************************************************/

void Left_I_go (uint32_t färg, uint16_t repetitioner, int mitten, int vänster)

baserat på colorWipe i strandtest. Här är hur "uint32_t c" hette i 'main ()' 50 var "vänta"!

/ * colorWipe (remsa. Color(255, 0, 0), 50); Röd

colorWipe (remsa. Color(0, 255, 0), 50); / / grön

colorWipe (remsa. Color(0, 0, 255), 50); / / blå * /

Strip. Color(_,_,_),Repeats,Middle,Left)

{//variables

uint8_t vänta = 20;

uint16_t i.

uint16_t z; "z" ser annorlunda än "i"

vill att det ska blinka några gånger, så att göra en nästlade for-loop

för (z = 0; z < = repetitioner; z ++)

{för (jag = mitten; jag > = vänster; i--)

{

strip.setPixelColor(i,color);

Strip.show();

Delay(Wait); }

en annan fördröjning att hålla dem för lite

Delay(100);

nu stänga av

> <> <

för (jag = mitten; jag > = vänster; i--)

{/ / strip.setPixelColor(pixel#,R,G,B);

strip.setPixelColor(i,0,0,0);

Strip.show();

}

Delay(100);

> <> <

}

}

/********************************************************************

* blinka höger *

********************************************************************/

void Right_then (uint32_t färg, uint16_t repetitioner, int mitten, int rätt

) {/ / / strip. Color(_,_,_),Repeats,Middle,Right)

variabler

uint8_t vänta = 20; göra kort

uint16_t i.

uint16_t z;

vill att det ska blinka några gånger, så att göra en nästlade for-loop

för (z = 0; z < = repetitioner; z ++)

{för (jag = mitten; jag < = höger; i ++)

{

strip.setPixelColor(i,color);

Strip.show();

Delay(Wait);

}

en annan fördröjning att hålla dem för lite

Delay(100);

nu stänga av

> <> <

för (jag = mitten; jag < = höger; i ++) //note hur jag bläddrade > till <-- och till ++

{

strip.setPixelColor(i,0,0,0);

Strip.show();

}

Delay(100); }

}

/********************************************************************

* söt skumpande blink *

********************************************************************/

HM. kanske det finns ett sätt att, um... ordet. göra standard blinka del av void loop(), som sätter det innan någon sensor kontrollerar, bör vara snabb nog, höger? lägga till en försening. Ja! Jag ska bara göra detta en en söt fancy version, två lampor bounching av varandra i mitten och av ändarna...

void Notice_me_Cute (uint32_t färg, uint16_t repetitioner, int kvar, int mitten, int rätt)

{/ / band. Color(_,_,_),Repeats,Left,Middle,Right)

strip.setPixelColor(pixel#,R,G,B);

variabler

uint8_t vänta = 50; lite långsammare än 20 för svarvning

uint16_t i.

uint16_t z;

för (z = 0; z < = repetitioner; z ++)

{

sätta på och stänga av mitt ljus

strip.setPixelColor(middle,color);

Strip.show();

Delay(Wait);

strip.setPixelColor(middle,0,0,0);

Strip.show();

nu för split

för (jag = 1; jag

{

strip.setPixelColor(middle-i,color); går åt vänster från center

strip.setPixelColor(middle+i,color); går rakt från center

Strip.show(); visas tillsammans?

Delay(Wait);

eftersom "en i taget" behöva stänga lampor av insidan för loop

strip.setPixelColor(middle-i,0,0,0);

strip.setPixelColor(middle+i,0,0,0);

Strip.show();

}

nu gå tillbaka till mitten

Kontrollera om några sensor ingång här vore det klokt om jag vill ha det upprepas mycket... men jag inte vet om det är möjligt/hur till

för (jag = 1, jag, jag--) //did (mitten-1) eftersom jag inte vill att kanterna blinkar två gånger, de är hit en gång när resten är borta två gånger i en cykel.

{

strip.setPixelColor(middle-i,color); Detta bör gå rätt från vänster

strip.setPixelColor(middle+i,color); och denna vänster från höger

Strip.show();

Delay(Wait);

strip.setPixelColor(middle-i,0,0,0);

strip.setPixelColor(middle+i,0,0,0);

Strip.show(); }

}

}

/********************************************************************

* dualFade (meh!) *

4. alternativ skulle vara coolt att koppla till ljud eller något annat i stället.

********************************************************************

/ något att kasta på pinky eftersom jag inte kan få regnbågen funktioner i strandtest att arbeta.

void dualFade (int kvar, int rätt)

{

för (int jag = 0; jag < 255; i = i + 1)

{

för (int k = vänster; k < = höger; k ++)

{

int klyftan = k %2.

om (dela upp == 0)

strip.setPixelColor (k, i, 0, 255-i);

annat

strip.setPixelColor (k, 0, i, 255-i);

Delay(10);

Strip.show(); }

}

}

/********************************************************************

* meh 2 *

********************************************************************

/ void dualFade2 (int kvar, int rätt)

{för (int jag = 0; jag < 255; i = i + 1) {

för (int k = vänster; k < = höger; k ++)

{int klyftan = k %2.

om (dela upp == 0)

strip.setPixelColor (k, i, 255-i, 0);

annat

strip.setPixelColor (k, 0, 255-i, i);

Delay(10);

Strip.show();

}

}

}