Stap 3: Gedrags Code Overview
Doelstellingen voor de schichtig Nightscape gedrags Code:
-3 aparte groepen voor LEDs: sterren, oog-paren en firefly, elk met een verschillend gedrag.
-Individuele sterren en oog-paren fungeren als afzonderlijke entiteiten
-De firefly functioneert als één entiteit
-De sterren in-en uitfaden, het nabootsen van een twinkeling. (Dit werd gedaan met behulp van puls breedte modulatie)
-De oog-paren knipperen willekeurig
-Alle fracties reageren op geluid en gedrag voortdurend te hervatten.
Hoe het werkt:
-Tijdens de hoofdlus is elke entiteit (ster, paar ogen, firefly) in slaap of wakker
-Wakker, willekeurige getallen worden gebruikt om te bepalen wanneer te knipperen/vervagen de ogen/sterren als de firefly blijft op zijn weg naar de volgende LED-pin
-Als in slaap, wordt de 'tijd in slaap' variabele verhoogd
Wanneer er een geluid (en de drempel is geschonden):
-Elke entiteit is ingesteld op in slaap, en de tijd in slaap begint verhogen
-Terwijl een entiteit in slaap is:
-Telkens wanneer die een slapende entiteit wordt bezocht, is een willekeurig getal gegenereerd en vergeleken met de tijd die de entiteit in slaap - als de tijd in slaap is groter, dat de entiteit wakker geweest.
-Dit leidt tot elke entiteit wordt gewekt willekeurig een onverpakt.
Kwesties en advies:
-Bij het schrijven van de gedrags code, de ingebouwde Arduino delay() functie moet worden vermeden omdat het alle andere processen gaande houdt. Dit is onhoudbaar met drie LED groepen gelijktijdig en anders gedraagt. In plaats daarvan kan het aantal iteraties van de hoofdlus worden gebruikt voor tijd afhankelijk zijn gedrag. Opmerking dat de tijd die nodig is voor elke iteratie van de hoofdlus afhankelijk van de hoeveelheid is dingen die u met gaande binnen het. Trial and error en de kunst van de verfijning zijn uw vrienden.
-Zoals beschreven in stap 3, hadden we onoverkomelijke Microfoongeluiden met de microfoon op dezelfde boord als de LED's gemanipuleerd wordt. Onze oplossing moest volledig scheiden de microfoon doordat het de enige component op een apart bord, de Arduino Uno.
De Code van de steekproef:
Dit is de code die we liep op de Arduino Mega tijdens operatie. Zie stap 2 voor de code moet worden uitgevoerd op de Uno.
---------------------------------------------------------------------------------------------------------------------
Eerst, moet u voor het initialiseren van de variabelen die uw klassen en de hoofdlus wordt gebruikt
int max_led = 50;
int star_twinkle_delay = 10;
Const int light_sensor = A0;
int sensorValue = 0;
int sensorMin = 1023; minimale sensor waarde
int sensorMax = 0;
int drempel = 255;
zweven a0 = 0,3; coeff voor lopende waarde
zweven a1 = 0,2; coeff voor plus & min 1 van calc
zweven a2 = 0,1; coeff voor plus & min 2 van calc
zweven a3 = 0,05; coeff voor plus & min 3 van calc
int sV_adjusted; opgeslagen aangepaste waarde
int sV_m3; sensor waarde 3 voorafgaand aan calc
int sV_m2; sensor waarde 2 voorafgaand aan calc
int sV_m1; sensor waarde 1 voorafgaand aan calc
int sV_0; sensor waarde wordt berekend, centrum van curve
int sV_p1; sensor waarde 1 na aan calc
int sV_p2; sensor waarde 2 na aan calc
int sV_p3; sensor-waarde 3 na aan calc (wat is actaully wordt gelezen)
Hier is waar uw 3 klassen (soorten LEDs) worden gedefinieerd. Ze hebben elk een setup en lus functie, net als de Arduino.
Ster
klasse ster
{
publiek:
int pin;
int vervagen;
int helderheid;
int wakker;
int time_asleep;
VOID setup_star()
{
wakker = 1;
vervagen = ASELECT() % 2;
helderheid = ASELECT() % max_led + 1;
}
VOID twinkle()
{
Als (wakker == 1)
{
Als (fading == 1)
{
helderheid += 1;
}
anders helderheid-= 1;
Als (helderheid > max_led)
{
helderheid = max_led;
vervagen = -1;
}
anders als (helderheid < 10)
{
helderheid = 10;
vervagen = 1;
}
analogWrite (pin, helderheid);
delay(1);
}
}
};
Ogen
klasse eye_pair
{
publiek:
int pin;
int wakker;
int knipperen;
int blink_duration;
int time_since_blink;
int time_asleep;
VOID setup_eyes()
{
wakker = 1;
time_since_blink = ASELECT() % 1000;
}
VOID display_eyes()
{
Als (wakker == 1)
{
Als (knipperen == 1)
{
digitalWrite (pin, laag);
blink_duration ++;
Als (blink_duration > ((rand() % 20) + 10))
{
knipperend = 0;
blink_duration = 0;
time_since_blink = 0;
}
}
Als (knipperen == 0)
{
digitalWrite (pin, hoge);
Als (time_since_blink > ((rand() % 1000) + 500))
{
knipperend = 1;
digitalWrite (pin, laag);
}
anders time_since_blink ++;
}
}
}
};
Firefly - grepen het is eigen pin instellen
klasse firefly
{
publiek:
int pinnen [12];
int de tijd;
int time_to_blink;
int on_off;
int current_pin;
int wakker;
int time_asleep;
VOID setup_firefly()
{
wakker = 1;
time_to_blink = 100;
for (int i = 0; ik < 12; i ++)
{
pinnen [i] = i + 40;
pinMode (pinnen [i], OUTPUT);
digitalWrite (pinnen [i], laag);
}
current_pin = 0;
}
VOID go_firefly()
{
Als (wakker == 1)
{
Uitschakelen
Als ((on_off == 1) & & (tijd > (ASELECT() % 100) + 400))
{
digitalWrite (pinnen [current_pin], laag);
tijd = 0;
on_off = 0;
}
inschakelen
Als ((on_off == 0) & & (tijd > time_to_blink))
{
current_pin = (current_pin + 1) % 12;
digitalWrite (pinnen [current_pin], hoge);
tijd = 0;
on_off = 1;
}
tijd ++;
}
}
};
Hiermee definieert u de sterren, ogen en firefly objecten - oproep firefly object frank net om het te onderscheiden
sterren sterren [12] ;// = {2,3,4,5,6,7,8,9,10,11,12,13};
eye_pair ogen [31];
Firefly frank;
Setup - geïnitialiseerd sterren, ogen, firefly en sensor
VOID Setup
{
Serial.begin(9600);
for (int i = 0; ik < 12; i ++)
{
sterren [i] .pin = i + 2;
pinMode (.pin van de sterren [i], OUTPUT);
Stars[i].setup_star();
}
for (int i = 0; ik < 16; i ++)
{
ogen [i] .pin = i + 24;
pinMode (.pin van de ogen [i], OUTPUT);
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);
}
Hoofdlus - gelezen in de audio-ingang, en daarna LEDs verwerkt
void loop
{
sV_p3 = analogRead(light_sensor);
aangepaste waarde berekenen
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);
Shift waarden rond voor de volgende iteratie
sV_m3 = sV_m2;
sV_m2 = sV_m1;
sV_m1 = sV_0;
sV_0 = sV_p1;
sV_p1 = sV_p2;
sV_p2 = sV_p3;
Als (sV_adjusted < drempel)
{
for (int i = 0; ik < 13; i ++)
{
Stars[i].Twinkle();
Als (sterren [i] .time_asleep > ((rand() % 100000000) + 3000))
{
sterren [i] .awake = 1;
sterren [i] .time_asleep = 0;
}
anders
{
sterren [i] .time_asleep ++;
}
}
for (int i = 0; ik < 30; i ++)
{
Eyes[i].display_eyes();
Als (ogen [i] .time_asleep > ((rand() % 100000000) + 3000))
{
ogen [i] .awake = 1;
ogen [i] .time_asleep = 0;
}
anders
{
ogen [i] .time_asleep ++;
}
}
Frank.go_firefly();
Als (frank.time_asleep > ((rand() % 100000000) + 3000))
{
Frank.Awake = 1;
Frank.time_asleep = 0;
}
anders
{
Frank.time_asleep++;
}
}
anders
{
for (int j = 0; j < 54; j ++)
{
digitalWrite (j, laag);
for (int i = 0; ik < 13; i ++)
{
sterren [i] .awake = 0;
}
for (int i = 0; ik < 30; i ++)
{
ogen [i] .awake = 0;
}
Frank.Awake = 0;
}
}
}
---------------------------------------------------------------------------------------------------------------------
Gedrags Code opmerkingen:
Je kan merken dat de convolutie gedrag ook in deze code wordt gezien. Deze convolutie is voorgevormde wordt op de analoge waarden die uitvoer worden door de Uno. Als een stabieler en minder luidruchtig microfoon (of een lichtsensor) werden gebruikt, het gebruik van de Uno kan worden geëlimineerd en deze code zou niet moeten worden veranderd.
