Étape 3: Code comportemental Overview
Objectifs pour le Code de comportement nocturne capricieux :
-3 séparer les groupes de LED : vedettes, des paires d’yeux et firefly, chacune avec un comportement distinct.
-Individu stars et de paires d’yeux agissent comme des entités distinctes
-La luciole fonctionne comme une seule entité
-Les stars se fanent dedans et dehors, imitant un clin d’oeil. (Cela a été fait à l’aide de la modulation de largeur d’impulsions)
-Les paires d’yeux clignotent au hasard
-Tous les groupes répondent aux sons et reprendre le comportement continuellement.
Comment ça marche:
-Au cours de la boucle principale, chaque entité (star, paire d’yeux, firefly) est éveillé ou endormi
-Si il est éveillé, nombres aléatoires sont utilisés pour déterminer le moment de clignotement/fondu les yeux/stars et la luciole continue sur son chemin vers la prochaine broche LED
-Si il est endormi, la variable « temps endormi » est augmentée
Quand il y a un son (et le seuil est violé) :
-Chaque entité est définie endormi, et temps endormi commence à augmenter
-Alors qu’une entité est endormie :
-Chaque fois qu’une entité endormie est visitée, un nombre aléatoire est généré et par rapport à la fois que l’entité a été endormie - si temps endormi est supérieure, que l’entité se réveille.
-Ceci conduit à chaque entité se faire réveillée au hasard à des moments différents.
Questions et conseils :
-Lorsque vous écrivez le code comportemental, le construit en Arduino fonction delay() doit être évitée car il peut contenir jusqu'à tous les autres processus en cours. C’est intenable, avec trois groupes de LED se comporter différemment et en même temps. Au lieu de cela, le nombre d’itérations de la boucle principale peut être utilisé pour un comportement dépendant au moment. Notez que le temps de que nécessaire pour chaque itération de la boucle principale est dépendante de la quantité trucs que vous ayez passe qu’il contient. Tâtonnements et l’art du raffinement sont vos amis.
-Comme indiqué dans l’étape 3, nous avons eu bruit microphone insurmontables avec le microphone étant sur la même carte que les LED qui est manipulé. Notre solution a été de séparer totalement le micro en le faisant être l’unique composant sur un tableau distinct, l’Arduino Uno.
Exemple de Code :
C’est le code que nous avons couru sur l’Arduino Mega pendant le fonctionnement. Pour le code à exécuter sur la Uno Voir l’étape 2.
---------------------------------------------------------------------------------------------------------------------
Tout d’abord, vous devez initialiser toutes les variables qui utiliseront vos classes et la boucle principale
int max_led = 50 ;
int star_twinkle_delay = 10 ;
const int light_sensor = A0 ;
int sensorValue = 0 ;
int sensorMin = 1023 ; valeur minimale de capteur
int sensorMax = 0 ;
seuil d’int = 255 ;
flotteur a0 = 0,3 ; Coeff pour valeur perçoivent
flotteur a1 = 0,2 ; Coeff de plus & moins 1 de calc
flotteur a2 = 0,1 ; Coeff de plus & moins 2 de calc
flotteur a3 = 0,05 ; Coeff de plus & moins 3 de calc
int sV_adjusted ; valeur ajustée stockée
int sV_m3 ; valeur de la sonde 3 avant calc
int sV_m2 ; valeur de la sonde 2 avant calc
int sV_m1 ; valeur de la sonde 1 avant calc
int sV_0 ; valeur de la sonde étant calculée, centre de la courbe
int sV_p1 ; valeur de la sonde 1 après à calc
int sV_p2 ; valeur de la sonde 2 après à calc
int sV_p3 ; valeur de la sonde 3 après à calc (ce qui est actaully est lu)
Voici où votre 3 classes (types de LEDs) sont définies. Ils ont chacun une fonction d’installation et de la boucle, à l’instar de l’Arduino.
Star
étoile de classe
{
public :
tige d’int ;
effacement de l’int ;
int luminosité ;
int éveillé ;
int time_asleep ;
Sub setup_star()
{
éveillé = 1 ;
décoloration = rand() % 2 ;
luminosité = rand() % max_led + 1 ;
}
Sub twinkle()
{
Si (éveillé == 1)
{
Si (décoloration == 1)
{
luminosité += 1 ;
}
d’autre luminosité-= 1 ;
Si (luminosité > max_led)
{
luminosité = max_led ;
décoloration = -1 ;
}
ElseIf (luminosité < 10)
{
luminosité = 10 ;
décoloration = 1 ;
}
analogWrite (pin, luminosité) ;
Delay(1) ;
}
}
};
Yeux
classe eye_pair
{
public :
tige d’int ;
int éveillé ;
int clignoter ;
int blink_duration ;
int time_since_blink ;
int time_asleep ;
Sub setup_eyes()
{
éveillé = 1 ;
time_since_blink = rand() % 1000 ;
}
Sub display_eyes()
{
Si (éveillé == 1)
{
Si (clignotant == 1)
{
digitalWrite (broches, faible) ;
blink_duration ++ ;
Si (blink_duration > ((rand() % 20) + 10))
{
clignote = 0 ;
blink_duration = 0 ;
time_since_blink = 0 ;
}
}
Si (clignotant == 0)
{
digitalWrite (tige, haute) ;
Si (time_since_blink > ((rand() % 1000) + 500))
{
clignote = 1 ;
digitalWrite (broches, faible) ;
}
d’autre time_since_blink ++ ;
}
}
}
};
Luciole - poignées c’est pin propre configuration
Luciole de classe
{
public :
broches int [12] ;
int temps ;
int time_to_blink ;
on_off int ;
int current_pin ;
int éveillé ;
int time_asleep ;
Sub setup_firefly()
{
éveillé = 1 ;
time_to_blink = 100 ;
pour (int i = 0; i < 12; i ++)
{
broches [i] = i + 40 ;
pinMode (broches [i], sortie) ;
digitalWrite (épingles [i], faible) ;
}
current_pin = 0 ;
}
Sub go_firefly()
{
Si (éveillé == 1)
{
Désactiver
Si ((on_off == 1) & & (temps > (rand() % 100) + 400))
{
digitalWrite (épingles [current_pin], faible) ;
temps = 0 ;
on_off = 0 ;
}
mettre en marche
Si ((on_off == 0) & & (temps > time_to_blink))
{
current_pin = (current_pin + 1) % 12 ;
digitalWrite (épingles [current_pin], HIGH) ;
temps = 0 ;
on_off = 1 ;
}
temps ++ ;
}
}
};
Définit des étoiles, des yeux et objets de la luciole - appel firefly objet frank juste pour se distinguer
étoiles étoiles [12];// = {2,3,4,5,6,7,8,9,10,11,12,13} ;
eye_pair yeux [31] ;
frank luciole ;
Installation - Initialise étoiles, yeux, firefly et capteur
void setup()
{
Serial.Begin(9600) ;
pour (int i = 0; i < 12; i ++)
{
Stars de broches [i] = i + 2 ;
pinMode (broches étoiles [i], sortie) ;
Stars[i].setup_star() ;
}
pour (int i = 0; i < 16; i ++)
{
broches d’yeux [i] = i + 24 ;
pinMode (broches yeux [i], sortie) ;
Eyes[i].setup_eyes() ;
}
Frank.setup_firefly() ;
sV_m3 = analogRead(light_sensor) ;
sV_m2 = analogRead(light_sensor) ;
sV_m1 = analogRead(light_sensor) ;
sV_0 = analogRead(light_sensor) ;
sV_p1 = analogRead(light_sensor) ;
sV_p2 = analogRead(light_sensor) ;
}
Boucle principale - lit en entrée audio, puis gère les LEDs
void loop()
{
sV_p3 = analogRead(light_sensor) ;
calculer la valeur ajustée
sV_adjusted = (int) (a3 * (float) sV_m3 + a2 * (float) sV_m2 + a1 * (float) sV_m1 + a0 * (float) sV_0 + a1 * (float) sV_p1 + a2 * (float) sV_p2 + a3*(float)sV_p3) ;
valeurs des déplacements autour de prochaine itération
sV_m3 = sV_m2 ;
sV_m2 = sV_m1 ;
sV_m1 = sV_0 ;
sV_0 = sV_p1 ;
sV_p1 = sV_p2 ;
sV_p2 = sV_p3 ;
Si (sV_adjusted < seuil)
{
pour (int i = 0; i < 13; i ++)
{
Stars[i].Twinkle() ;
Si (les étoiles [i] .time_asleep > ((rand() % 100000000) + 3000))
{
les étoiles [i] .awake = 1 ;
les étoiles [i] .time_asleep = 0 ;
}
d’autre
{
les étoiles [i] .time_asleep ++ ;
}
}
pour (int i = 0; i < 30; i ++)
{
Eyes[i].display_eyes() ;
Si (les yeux [i] .time_asleep > ((rand() % 100000000) + 3000))
{
.awake yeux [i] = 1 ;
les yeux [i] .time_asleep = 0 ;
}
d’autre
{
les yeux [i] .time_asleep ++ ;
}
}
Frank.go_firefly() ;
Si (frank.time_asleep > ((rand() % 100000000) + 3000))
{
Frank.Awake = 1 ;
Frank.time_asleep = 0 ;
}
d’autre
{
Frank.time_asleep++ ;
}
}
d’autre
{
pour (int j = 0; j < 54; j ++)
{
digitalWrite (j, faible) ;
pour (int i = 0; i < 13; i ++)
{
les étoiles [i] .awake = 0 ;
}
pour (int i = 0; i < 30; i ++)
{
les yeux [i] .awake = 0 ;
}
Frank.Awake = 0 ;
}
}
}
---------------------------------------------------------------------------------------------------------------------
Notes du Code comportemental :
Vous pouvez remarquer que le comportement de convolution est vu dans ce code aussi. Cette convolution est étant réalisée sur les valeurs analogiques qui sont sorties par l’ONU. Si un micro plus stable et moins bruyant (ou un capteur de lumière) ont été utilisé, l’utilisation de l’ONU pourrait être éliminée et ce code n’aurait pas à être changé.
