Étape 7: Séquences plus
Nous avons une séquence qui commence sur la broche 3 et chaque LED via broche 10 s’allume, puis recommence à la broche 3. Supposons que vous vouliez les LEDs en lumière en séquence et retourne la direction opposée ? Nous pouvons ajouter cet effet ping-pong en ajoutant une autre boucle après la première boucle et faire ce un chef vers le bas.
pour (i = 7; i > = 0; i--) {}
digitalWrite (posPins [i], HIGH) ;
delay_(t_delay) ;
digitalWrite (posPins [i], faible) ;
Delay(t_delay) ;
}
Maintenant nous avons deux séquences, ainsi notre deuxième séquence ping-pongs par comptage puis le compte à rebours. Comment nous sélectionnons chacun d'entre eux lorsque le bouton est enfoncé, consiste à sélectionner dans une liste de séquences à l’aide de l’instruction « switch ».
L’instruction Switch utilise une variable, que nous avions fixés, il compare la valeur de cette variable à un ensemble de valeurs, telles que des instructions de condition multiple, si la condition est remplie, il exécute les instructions qui se trouvent dans la portée de l’instruction case. Il prend la forme suivante :
{Switch(variable)}
cas 1 :
instructions de code
rupture ;
cas 2 :
instructions de code
rupture ;
par défaut :
instructions de code
rupture ;
}
L’instruction Switch est passée à une variable, puis la valeur de cette variable est vérifiée contre les valeurs pour chaque instruction case, que puis il exécute les instructions de code dans le cadre de cette évaluation et de la rupture de sa clôture;.
Une fois que nous avons une façon de gérer les différentes séquences, nous avons besoin d’un moyen de recevoir des entrées d’utilisateur pour modifier les États ; C’est là qu’intervient le bouton.
Nous vous montrons un bouton à la broche 11. Le bouton est dans un État normalement ouvert, et la broche 11 est liée à la terre à travers une résistance de limitation de courante de 10K ohms. Lorsque le bouton est enfoncé, il relie la broche 11, à V ++ qui est le + 5V fournie par le régulateur de puissance de la Mini. Le chemin sera de V ++ à la broche 11 et non pas par la résistance à la terre lorsque le bouton est enfoncé, parce que le chemin d’accès entre + 5V et la terre sera le chemin de moindre résistance.
Une fois que le bouton est enfoncé, et il y a un sommet sur la broche 11, nous lisons, nous en ajouter à la variable de séquence. Après que nous incrémentons la variable de séquence, nous vérifions pour vous assurer que sa valeur ne dépasse pas le nombre de séquences (instructions case) nous avons. S’il est supérieur, nous le réinitialiser pour faire référence à la première instruction case, à partir des séquences partout.
NOTE : je n’utilise pas l’instruction case par défaut donc il y a des déclarations dans sa portée, afin de ne rien d’autre que la fin avec une instruction break.
Maintenant, pour mettre le tout, le code suivant a deux séquences, le premier est l’ordre linéaire, avec que nous avons commencés et le second est la séquence de ping-pong.
/ * Fleur LED
* Rédigé par Mark S. Drummond, (gravité Boy) 2009
* Vous êtes libre d’utiliser, distribuer, modifier, copiez le code suivant.
* Aucun crédit serait appréciée
*
int NB = 255 ;
temp int = 0 ;
int binNum [8] ;
int maxLED = 8 ;
int maxSequence = 6 ;
int seqButton = 11 ;
séquence d’int = 1 ;
int buttonVal = faible ;
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 ;
Malik int = 50 ;
/ * setup() fonction d’initialisation, le mot « void » avant le nom de la fonction signifie que la fonction ne retourne pas une valeur. */
void setup() {}
Serial.Begin(9600) ;
pinMode (negPin, sortie) ;
digitalWrite (negPin, basse) ;
pour (i = 0; i < maxLED; i ++) {}
pinMode (posPins [i], sortie) ;
digitalWrite (posPins [i], faible) ;
}
}
/ * Après toutes les variables sont déclarées et setup() est exécutée, cette fonction fera une boucle encore et encore, c’est la boucle principale. */
void loop() {}
buttonVal = digitalRead(seqButton) ;
if(buttonVal == High) {/ / lire la valeur de broche et vérifier si haut
séquence ++ ; valeur d’incrément séquence
Delay(t_delay * 10) ; Arrêter le bouton d’enregistrement
plusieurs presses
Si (séquence > maxSequence) {séquence = 1;}
}
commutateur (séquence) {}
cas 1: séquence de //straight
pour (i = 0; i < maxLED; i ++) {}
digitalWrite (posPins [i], HIGH) ;
Delay(t_delay) ;
digitalWrite (posPins [i], faible) ;
Delay(t_delay) ;
}
rupture ;
cas 2: //Ping pong
vers l’avant
pour (i = 0; i < maxLED; i ++) {}
digitalWrite (posPins [i], HIGH) ;
Delay(t_delay) ;
digitalWrite (posPins [i], faible) ;
Delay(t_delay) ;
}
sens inverse
pour (i = (maxLED - 1); i > = 0; i--) {/ / nous comptons vers le bas à zéro, total - 1
digitalWrite (posPins [i], HIGH) ;
Delay(t_delay) ;
digitalWrite (posPins [i], faible) ;
Delay(t_delay) ;
}
rupture ;
case 3: / / tous les activer/désactiver
t_delay = 60 ;
pour (i = 0; i < = maxLED; i ++) {}
digitalWrite (posPins [i], t) ;
Delay(t_delay) ;
digitalWrite (posPins [i], faible) ;
Delay(t_delay) ;
bascule t
Si (t == 0) {}
t = 1 ;
}
else {}
t = 0 ;
}
}
t_delay = 30 ;
rupture ;
case 4: / / cette séquence s’allume les LEDs du Centre des
p_offset = 4 ;
n_offset = 3 ;
pour (i = 0; j’ai < (maxLED/2); i ++) {//start au centre et comte d’extrémités
digitalWrite (posPins [p_offset], HIGH) ;
digitalWrite (posPins [n_offset], HIGH) ;
Delay(t_delay) ;
digitalWrite (posPins [p_offset], faible) ;
digitalWrite (posPins [n_offset], faible) ;
Delay(t_delay) ;
++ p_offset ; leur lumière dans une seule direction
--n_offset ; tout en eux l’éclairage dans l’autre sens
}
rupture ;
cas 5: / / random LED clignotantes
pour (i = 0; i < maxLED; i ++) {}
srand(Rand()) ; Définition de la graine à l’aide de la fonction rand
int NombrAl = (rand()%maxLED) ; nombre aléatoire compris entre 0 et maxLEDs
digitalWrite (posPins [NombrAl], HIGH) ;
Delay(t_delay/4) ; accélérer le retard afin qu’il brille
digitalWrite (posPins [NombrAl], faible) ;
Delay(t_delay/4) ;
}
rupture ;
case 6: / / démarrage rapide et fin lente, peut l’utiliser avec différents modèles.
pour (i = 0; i < maxLED; i ++) {}
digitalWrite (posPins [i], HIGH) ;
Delay((t_delay/2) + (j’ai * Malik)) ;
digitalWrite (posPins [i], faible) ;
Delay(t_delay) ;
}
rupture ;
cas 7: //Binary compteur, compte en binaire sur 8 LEDs
N’oubliez pas d’utiliser ce moment vous avez la résistance adéquate pour chaque LED
pour (i = 0; i < 255; i ++) {}
int compteur = 0 ;
int index = maxLED - 1 ;
num = i ;
Temp = num ;
tandis que (num > 0) {}
++ contrer ;
Si (num % 2 == 0) {binNum [index] = 0;}
else {binNum [index] = 1;}
num = num / 2 ;
--l’index ;
} / / après alors que la boucle s’arrête, le reste de [binNum] est rempli par des 0 (MSB -> LSB)
/ * Pardonner le format en ligne pour les boucles, une fois que vous les connaissez, ils sont une lecture facile * /
pour (t = 0; t < (maxLED - compteur); t ++) {binNum [t] = 0;}
pour (t = 0; t < maxLED -1; t ++) {digitalWrite (posPins [t], binNum[t]);}
Delay(t_delay/2) ;
pour (t = 0; t < maxLED - 1; t ++) {digitalWrite (posPins [t], LOW);}
}
Delay(t_delay * 10) ;
rupture ;
par défaut :
rupture ;
} / / fin instruction switch
} / / fin de fonction loop() principal
Copiez le code et une fois que le programme démarre, appuyez sur le bouton pour changer l’ordre linéaire à la séquence de ping-pong. Nous pouvons continuer à ajouter des nouvelles séquences en ajoutant des instructions case plus avant l’instruction case par défaut. L’instruction switch peut servir à tester n’importe quelle valeur d’un int, char ou Boolean. Vous pouvez même imbriquer l’instruction switch si vous souhaitiez ajouter quelques variations de vitesse fixée à une séquence.
Il y a un autre bloc ajouté du code au début de la fonction loop() principal et avant l’instruction Switch ; Ceci est utilisé pour lire la valeur du bouton et incrémenter la variable de séquence de nos, il teste aussi la variable afin d’être sûr que c’est au sein de la gamme avant d’entrer dans l’instruction Switch ; Si la variable est supérieur au nombre d’instructions case, remis à 1, qui est la première instruction case.
buttonVal = digitalRead(seqButton) ; lire l’état du bouton
if(buttonVal == High) {/ / lire la valeur de broche et vérifier si haut
séquence ++ ; valeur d’incrément séquence
Delay(t_delay * 10) ; Arrêter le bouton d’enregistrement
plusieurs presses
Si (séquence > maxSequence || séquence < 0) {séquence = 1;}
}
Le délai a été fixé à pousser le temps à 1000 ms ou 1 seconde pour tenir compte de la! la vitesse de l’humain en appuyant sur le bouton. Notez que j’ai ajouté le second test conditionnel de séquence < 0 dans l’exemple ci-dessus et non dans le code. Les deux barres || est une valeur booléenne ou, alors soit déclaration étant vrai serait la condition et mis en séquence = 1. Si la première séquence > 2 est true, puis séquence < 0 n’encore être évalué.
Une astuce pour ajouter des séquences plus consiste à définir la séquence juste après le contrôle de bouton au début de la loop() principal, définissez la valeur de séquence à faire référence à l’affaire que vous travaillez sur. Si vous travaillez sur une nouvelle séquence de cas 3: et vous souhaitez exécuter le test, mais ne voulez pas appuyer sur le bouton chaque fois pour voir la séquence vous travaillez sur, puis utilisez la force brutale, comme illustré ci-dessous.
buttonVal = digitalRead(seqButton) ;
if(buttonVal == High) {}
séquence ++ ;
Delay(t_delay * 10) ;
Si (séquence > maxSequence) {séquence = 1;}
}
séquence = 3 ; substituer le code ci-dessus et la séquence, sur que nous travaillons la force
Cela définira explicitement la valeur de la séquence à 3 après que le bouton lire. Je vais inclure des séquences supplémentaires conçus pour la fleur dans le fichier PDF à la fin de ce Instructable. J’ai été déconner avec les valeurs analogiques des broches analogiques que certains des LEDs sont liés, avec la diffusion et un fondu lent était dedans et dehors, un bel effet. Ramping up et down peut être accompli avec une pour boucle et croissantes et décroissantes des valeurs entre + 0V et + 5V.
