Paso 3: Código conductual Resumen
Objetivos para el código de conducta caprichosa nocturno:
-3 grupos de LEDs separados: estrellas, pares de ojos y firefly, cada uno con un comportamiento distinto.
-Stars individuo y pares de ojos actúan como entidades separadas
-La luciérnaga funciona como una entidad
-Las estrellas se desvanecen en y hacia fuera, imitando un centelleo. (Esto se hizo mediante modulación de anchura de pulso)
-Los pares de ojos parpadean aleatoriamente
-Todos los grupos responden al sonido y reanudar comportamiento continuamente.
Cómo funciona:
-Durante el bucle principal, cada entidad (estrellas, ojos par, firefly) es ya sea despierto o dormido
-Si despierto, números aleatorios se utilizan para determinar cuándo parpadea/se descolora las ojos/estrellas, y la luciérnaga sigue en su camino hacia el siguiente pin LED
-Si está dormido, se incrementa la variable 'tiempo dormido'
Cuando hay un sonido (y el umbral se viola):
-Cada entidad se establece en dormido y dormido comience aumentar
-Mientras que una entidad está dormida:
-Cada vez que se visita una entidad para dormir, un número aleatorio es generado y en comparación con el tiempo que la entidad ha sido dormida - si tiempo dormido es mayor, que la entidad se despierta.
-Esto lleva a cada entidad ser despertado al azar en diferentes momentos.
Problemas y consejos:
-Cuando el código de conducta, construido en Arduino función delay() debe evitarse porque sostiene todos los procesos en la escritura. Esto es insostenible con tres grupos de LED, comportarse de manera diferente y al mismo tiempo. En cambio, el número de iteraciones del bucle principal puede ser uso para el comportamiento dependiente del tiempo. Tenga en cuenta que el tiempo que toma para cada iteración del bucle principal depende de la cantidad de cosas que lo que pasa dentro de ella. Ensayo y error y el arte del refinamiento son tus amigos.
-Como se explica en el paso 3, hemos tenido ruido micrófono insuperable con el micrófono en la misma junta como manipula el LED. Nuestra solución fue separar completamente el micrófono por lo que tiene ser el único componente en un tablero separado, el Arduino Uno.
Código de ejemplo:
Este es el código que funcionó en el Arduino Mega durante la operación. Consulte el paso 2 para que el código a ejecutar en la ONU.
---------------------------------------------------------------------------------------------------------------------
En primer lugar, debe inicializar todas las variables que utilizarán sus clases y el bucle principal
int max_led = 50;
int star_twinkle_delay = 10;
const int light_sensor = A0;
int sensorValue = 0;
int sensorMin = 1023; valor de la sonda de mínima
sensorMax int = 0;
umbral de int = 255;
flotador de a0 = 0,3; coeficiente para el valor actual
flotador de a1 = 0.2; coeficientes para plus y minus 1 de calc
flotador de a2 = 0.1; coeficientes de para más y menos 2 de calc
flotador de a3 = 0. 05; coeficientes para plus y minus 3 de calc
int sV_adjusted; valor ajustado
int sV_m3; valor del sensor 3 anterior a calc
int sV_m2; valor del sensor 2 previo a calc
int sV_m1; valor del sensor 1 previo a calc
int sV_0; valor del sensor se calcula, centro de curva
int sV_p1; valor del sensor 1 después a calc
int sV_p2; valor sensor 2 después de calc
int sV_p3; valor del sensor 3 después a calc (Qué es actaully ser leído)
Aquí es donde se definen 3 clases (tipos de LEDs). Cada uno de ellos tiene una función configuración y lazo, al igual que el Arduino.
Estrella
estrellas de clase
{
público:
int pin;
int descoloramiento;
int brillo;
int despierto;
int time_asleep;
void setup_star()
{
despierta = 1;
decoloración = rand() % 2;
brillo = rand() % max_led + 1;
}
void twinkle()
{
Si (despierto == 1)
{
Si (decoloración == 1)
{
brillo += 1;
}
más brillo-= 1;
Si (brillo > max_led)
{
brillo = max_led;
decoloración = -1;
}
else if (brillo < 10)
{
brillo = 10;
decoloración = 1;
}
analogWrite (pin, brillo);
Delay(1);
}
}
};
Ojos
clase eye_pair
{
público:
int pin;
int despierto;
int parpadea;
int blink_duration;
int time_since_blink;
int time_asleep;
void setup_eyes()
{
despierta = 1;
time_since_blink = rand() % 1000;
}
void display_eyes()
{
Si (despierto == 1)
{
Si (parpadeo == 1)
{
digitalWrite (pin, LOW);
blink_duration ++;
Si (blink_duration > ((rand() % 20) + 10))
{
parpadeo = 0;
blink_duration = 0;
time_since_blink = 0;
}
}
Si (parpadeo == 0)
{
digitalWrite (pin, HIGH);
Si (time_since_blink > ((rand() % 1000) + 500))
{
parpadeo = 1;
digitalWrite (pin, LOW);
}
otra cosa time_since_blink ++;
}
}
}
};
Firefly - manijas propias pin configuración
Luciérnaga de clase
{
público:
pasadores de int [12];
int tiempo;
int time_to_blink;
int on_off;
int current_pin;
int despierto;
int time_asleep;
void setup_firefly()
{
despierta = 1;
time_to_blink = 100;
para (int i = 0; i < 12; i ++)
{
alfileres [i] = i + 40;
pinMode (pernos [i], salida);
digitalWrite (pins [i], LOW);
}
current_pin = 0;
}
void go_firefly()
{
Si (despierto == 1)
{
Apaga
Si ((on_off == 1) & & (tiempo > (rand() % 100) + 400))
{
digitalWrite (pins [current_pin], LOW);
tiempo = 0;
ON_OFF = 0;
}
encender
Si ((on_off == 0) & & (tiempo > time_to_blink))
{
current_pin = (current_pin + 1) % 12;
digitalWrite (pins [current_pin], HIGH);
tiempo = 0;
ON_OFF = 1;
}
tiempo ++;
}
}
};
Define estrellas, ojos y objetos de firefly - llamada firefly objeto frank para distinguirlo
estrellas estrellas [12] ;// = {2,3,4,5,6,7,8,9,10,11,12,13};
ojos de eye_pair [31];
frank de la luciérnaga;
Configuración - inicializa estrellas, ojos, firefly y sensor
void setup()
{
Serial.Begin(9600);
para (int i = 0; i < 12; i ++)
{
Stars [i] .pin = i + 2;
pinMode (.pin estrellas [i], salida);
Stars[i].setup_star();
}
para (int i = 0; i < 16; i ++)
{
.pin ojos [i] = i + 24;
pinMode (ojos [i] .pin, salida);
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);
}
Bucle principal - lee en entrada de audio, y luego se encarga de LEDs
void loop()
{
sV_p3 = analogRead(light_sensor);
calcular el valor ajustado
sV_adjusted = (int) (a3 * (float) sV_m3 + a2 * (float) sV_m2 + a1 * (float) sV_m1 + a0 * sV_0 (flotador) + a1 * (float) sV_p1 + a2 * (float) sV_p2 + a3*(float)sV_p3);
valores de cambio alrededor para la siguiente iteración
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 < umbral)
{
para (int i = 0; i < 13; i ++)
{
Stars[i].Twinkle();
Si (estrellas [i] .time_asleep > ((rand() % 100000000) + 3000))
{
estrellas [i] .awake = 1;
estrellas [i] .time_asleep = 0;
}
otra cosa
{
.time_asleep de estrellas [i] ++;
}
}
para (int i = 0; i < 30; i ++)
{
Eyes[i].display_eyes();
Si (ojos [i] .time_asleep > ((rand() % 100000000) + 3000))
{
ojos [i] .awake = 1;
ojos [i] .time_asleep = 0;
}
otra cosa
{
.time_asleep de ojos [i] ++;
}
}
Frank.go_firefly();
Si (frank.time_asleep > ((rand() % 100000000) + 3000))
{
Frank.Awake = 1;
Frank.time_asleep = 0;
}
otra cosa
{
Frank.time_asleep++;
}
}
otra cosa
{
para (int j = 0; j < 54; j ++)
{
digitalWrite (j, LOW);
para (int i = 0; i < 13; i ++)
{
estrellas [i] .awake = 0;
}
para (int i = 0; i < 30; i ++)
{
ojos [i] .awake = 0;
}
Frank.Awake = 0;
}
}
}
---------------------------------------------------------------------------------------------------------------------
Información sobre código de conducta:
Usted puede notar que el comportamiento de la convolución se ve también en este código. Esta convolución es ser preformado en los valores analógicos que están siendo salida por la ONU. Si se utiliza un micrófono más estable y menos ruidoso (o un sensor de luz), se podría eliminar el uso de la ONU y este código no tendría que ser cambiado.
