Stap 7: Meer sequenties
We hebben een reeks die begint op pin 3 en brandt de LED via pin 10, dan begint op pin 3 opnieuw. Stel dat u de LEDs licht in de juiste volgorde en terugsturen van de tegenovergestelde richting gezocht? We kunnen dit ping-pong-effect toevoegen door een andere lus toe te voegen na de eerste lus, en dit één telling naar beneden.
voor (ik = 7; ik > = 0; i--) {}
digitalWrite (posPins [i], hoge);
delay_(t_delay);
digitalWrite (posPins [i], laag);
delay(t_delay);
}
Nu hebben we twee reeksen, zodat onze tweede volgnummer ping-pongs door tellen vervolgens aftellen. Hoe selecteren we elkaar wanneer de knop wordt ingedrukt, is om ze te selecteren uit een lijst met reeksen met behulp van de instructie "switch".
De instructie Switch maakt gebruik van een variabele, die we ingesteld, vergelijkt de waarde van die variabele naar een verzameling waarden, zoals meerdere instructies voor een voorwaarde, als voorwaarde wordt voldaan het worden de instructies die binnen het toepassingsgebied van de case-instructie uitgevoerd. Het heeft de volgende vorm:
switch(variable) {}
Case 1:
code-instructies
breken;
Case 2:
code-instructies
breken;
standaard:
code-instructies
breken;
}
De instructie Switch een variabele wordt doorgegeven, dan de waarde van die variabele wordt vergeleken met de waarden voor elk case-statement, dat het zal dan het uitvoeren van de code-instructies binnen de werkingssfeer van die zaak evaluatie en haar afsluitende pauze;.
Zodra we hebben een weg van het runnen van verschillende reeksen, moeten we enkele manier van het ontvangen van gebruikersinvoer om te veranderen van de Staten; Dit is waar de knop komt.
We hebben een knop aangesloten op pin 11. De knop is in een normaal open staat, en pin 11 is gebonden aan de grond door middel van een weerstand van de huidige beperking van 10K Ohm. Wanneer de knop wordt ingedrukt, bindt pin 11, aan V ++ oftewel de + 5V geboden door de Mini's macht regulator. Het pad zullen vanaf V ++ aan op pin 11 en niet via de weerstand aan de grond wanneer de knop is ingedrukt omdat het pad tussen de + 5V en ground zullen het pad van de minste weerstand.
Zodra de knop wordt ingedrukt en we lezen dat er is een hoog op pin 11, toevoegen we aan de reeks-variabele. Nadat we de variabele volgorde verhogen, controleren wij om ervoor te zorgen dat de waarde niet meer bedraagt dan het aantal sequenties (case-statements) we hebben. Als het groter is, wij opnieuw instellen als u verwijst naar de eerste case-statement, de sequenties helemaal beginnen.
Opmerking: Ik ben niet met behulp van de standaard case-statement dus er verklaringen binnen haar werkingssfeer, zijn dus het doet niets maar eindigen met een instructie break.
Nu de volgende code om het allemaal samen, twee reeksen, de eerste is de lineaire opeenvolging die we zijn begonnen met en de tweede is de volgorde van de ping-pong.
/ * Bloem LED
* Geschreven door Mark S. Drummond, (Ernst Boy) 2009
* U bent vrij om te gebruiken, te verspreiden, te wijzigen, deze code.
* Ieder krediet zou worden gewaardeerd
*
int num = 255;
int. temp = 0;
int binNum [8];
int maxLED = 8;
int maxSequence = 6;
int seqButton = 11;
int reeks = 1;
int buttonVal = laag;
int negPin = 2;
int posPins [] = {3,4,5,6,7,8,9,10};
int i, t;
int t_delay = 100;
int p_offset = 0;
int n_offset = 0;
int tSTEP = 50;
/ * Setup initialisatie functie, het woord "ongeldig" voor de functienaam betekent dat de functie geen waarde retourneert. */
VOID Setup {}
Serial.begin(9600);
pinMode (negPin, OUTPUT);
digitalWrite (negPin, laag);
voor (ik = 0; ik < maxLED; i ++) {}
pinMode (posPins [i], OUTPUT);
digitalWrite (posPins [i], laag);
}
}
/ * Dit is de hoofdlus nadat alle variabelen worden gedeclareerd en Setup wordt uitgevoerd, deze functie wordt herhaald over en voorbij. */
void loop {}
buttonVal = digitalRead(seqButton);
if(buttonVal == High) {/ / Lees de pin waarde en controleer of hoge
reeks ++; Increment reeks waarde
delay(t_delay * 10); De stopknop van opname
meerdere persen
Als (reeks > maxSequence) {reeks = 1;}
}
schakelaar (volgorde) {}
geval 1: //straight-reeks
voor (ik = 0; ik < maxLED; i ++) {}
digitalWrite (posPins [i], hoge);
delay(t_delay);
digitalWrite (posPins [i], laag);
delay(t_delay);
}
breken;
geval 2: //Ping pong
voorwaartse richting
voor (ik = 0; ik < maxLED; i ++) {}
digitalWrite (posPins [i], hoge);
delay(t_delay);
digitalWrite (posPins [i], laag);
delay(t_delay);
}
richting omkeren
voor (ik = (maxLED - 1); Ik > = 0; i--) {/ / Wij zijn aftellen tot nul, totale - 1
digitalWrite (posPins [i], hoge);
delay(t_delay);
digitalWrite (posPins [i], laag);
delay(t_delay);
}
breken;
Case 3: / / elke andere in-/ uitschakelen
t_delay = 60;
voor (ik = 0; ik < = maxLED; i ++) {}
digitalWrite (posPins [i], t);
delay(t_delay);
digitalWrite (posPins [i], laag);
delay(t_delay);
Toggle t
Als (t == 0) {}
t = 1;
}
else {}
t = 0;
}
}
t_delay = 30;
breken;
geval 4: / / deze reeks zal oplichten van de LEDs vanuit Midden
p_offset = 4;
n_offset = 3;
voor (ik = 0; ik < (maxLED/2); i ++) {//start bij het center en graaf aan uiteinden
digitalWrite (posPins [p_offset], hoge);
digitalWrite (posPins [n_offset], hoge);
delay(t_delay);
digitalWrite (posPins [p_offset], laag);
digitalWrite (posPins [n_offset], laag);
delay(t_delay);
++ p_offset; licht hen in één richting
--n_offset; terwijl ze in de andere richting verlichting
}
breken;
geval 5: / / willekeurige knipperende LEDs
voor (ik = 0; ik < maxLED; i ++) {}
srand(rand()); Instellen van het zaad met behulp van de functie ASELECT
int randomNumber = (rand()%maxLED); willekeurig getal tussen 0 en maxLEDs
digitalWrite (posPins [randomNumber], hoge);
delay(t_delay/4); versnellen de vertraging zodat het sparkles
digitalWrite (posPins [randomNumber], laag);
delay(t_delay/4);
}
breken;
kast 6: / / snel starten en eindigen langzaam, kunt u dit met verschillende patronen.
voor (ik = 0; ik < maxLED; i ++) {}
digitalWrite (posPins [i], hoge);
delay((t_delay/2) + (ik * tSTEP));
digitalWrite (posPins [i], laag);
delay(t_delay);
}
breken;
geval 7: //Binary teller, telt in binaire op 8 LEDs
Zorg ervoor dat u dit wanneer u de juiste weerstand voor elke LED hebt
voor (ik = 0; ik < 255; i ++) {}
int counter = 0;
int index = maxLED - 1;
num = i;
Temp = num;
terwijl (num > 0) {}
++ bestrijden;
Als (num % 2 == 0) {binNum [index] = 0;}
else {binNum [index] = 1;}
num = num / 2;
--index;
} / / na terwijl lus breekt, de rest van binNum [] is gevuld met 0s (MSB -> LSB)
/ * Vergeef het inline-formaat voor de for-lussen, als je eenmaal hen weet, zij zijn een makkelijk te lezen * /
voor (t = 0; t < (maxLED - teller); t ++) {binNum [t] = 0;}
voor (t = 0; t < maxLED -1; t ++) {digitalWrite (posPins [t], binNum[t]);}
delay(t_delay/2);
voor (t = 0; t < maxLED - 1; t ++) {digitalWrite (posPins [t], laag);}
}
delay(t_delay * 10);
breken;
standaard:
breken;
} / / einde van de instructie switch
} / / einde van belangrijkste loop functie
Kopieer de code, en zodra het programma wordt gestart, drukt u op de knop verandert de lineaire volgorde in het ping-pong-reeks. We kunnen houden toe te voegen nieuwe reeksen gegenereerd door het toevoegen van meer case-statements voordat de standaard case-statement. De instructie switch kan worden gebruikt om een waarde uit een int, char of Boolean te testen. U kunt zelfs de schakelaarverklaring nesten wanneer u wilden voor toevoegen sommige variaties van de ingestelde snelheid in een reeks.
Er is een andere toegevoegde blok van code aan het begin van de belangrijkste loop-functie en vóór de instructie Switch; Dit wordt gebruikt om de waarde van de knop lezen en verhogen onze reeks-variabele, het tests ook de variabele om te controleren of dat het zich binnen het bereik alvorens de schakelaarverklaring; Als de variabele hoger is dan het aantal case-statements, teruggezet op 1, dat de eerste case-statement is.
buttonVal = digitalRead(seqButton); Lees knoptoestand
if(buttonVal == High) {/ / Lees de pin waarde en controleer of hoge
reeks ++; Increment reeks waarde
delay(t_delay * 10); De stopknop van opname
meerdere persen
Als (reeks > maxSequence || volgnummer < 0) {reeks = 1;}
}
De vertraging was ingesteld op zet de tijd op 1000 ms of 1 seconde voor de! snelheid van de mens door de knop te drukken. Merk op dat ik de tweede voorwaardelijke test voor volgorde < 0 toegevoegd in het bovenstaande voorbeeld, en niet in de code. De twee bars || is een Booleaans of, zodat waar verklaring zou voldoen aan de voorwaarde en volgorde = 1. Als de eerste reeks > 2 waar is, zal vervolgens volgorde < 0 niet zelfs worden geëvalueerd.
Een truc om toe te voegen meer sequenties is volgorde direct na de knop controle instellen aan het begin van de belangrijkste loop, stelt u de waarde van sequentie om te verwijzen naar het geval dat je bezig bent. Als u aan een nieuwe reeks voor case 3 werkt: en je test wilt uitvoeren, maar wil niet te druk op de knop elke keer om te zien de volgorde je bezig bent, gebruik dan brute kracht zoals hieronder getoond.
buttonVal = digitalRead(seqButton);
if(buttonVal == High) {}
reeks ++;
delay(t_delay * 10);
Als (reeks > maxSequence) {reeks = 1;}
}
volgorde = 3; de bovenstaande code overschrijven en dwingen de volgorde die we werken aan
Dit zal de waarde van de reeks expliciet ingesteld op 3, nadat de knop lezen. Ik zal extra sequenties die zijn ontworpen voor de bloem in het PDF-bestand aan het einde van dit Instructable omvatten. Ik was messing rond met de analoge waarden van de analoge pinnen dat sommige van de LED's zijn gebonden aan, met de verspreiding en een langzame fade in en uit, een leuk effect was. Ramping omhoog en omlaag kan worden bereikt met een for loop en verhogen en afnemende tussen waarden + 0V en + 5V.
