|
|
## Lab Notebook Lesson 3
|
|
|
|
|
|
**Date:** 26. Februar 2015
|
|
|
**Date:** 26. Februar 2015 & 2. Marts
|
|
|
|
|
|
**Group members participating:** Mikkel Brun Jakobsen, Christoffer Skovgaard, Daniel Vestergaard og Josephine Thomsen.
|
|
|
|
|
|
**Activity duration:** 3 hours
|
|
|
**Activity duration:** 5 timer & 3 timer
|
|
|
|
|
|
## Goal
|
|
|
Målet med denne lesson er at eksperimentere med NXT Lydsensor.
|
|
|
Målet med denne lesson er at eksperimentere med NXT Lydsensor for at få en bedre forståelse af hvordan den fungere, og hvad den kan bruges til.
|
|
|
|
|
|
## Plan
|
|
|
Vores plan er at følge instruktionerne for de 6 exercises tilhørende Lesson 3 [1].
|
... | ... | @@ -16,46 +16,49 @@ Vores plan er at følge instruktionerne for de 6 exercises tilhørende Lesson 3 |
|
|
|
|
|
### Exercise 1 - Test of the Sound Sensor
|
|
|
|
|
|
I denne exercise lavede vi tre slags lyde: et klap, en sinus kurve afspillet fra en computer, og en testperson der siger "Hallo". Fra tre forskelllige afstande. Vi oplevede at det var meget svært at nå at registrere lydsensorens måling ved f.eks. et klap, da denne lyd kun strækker sig over få millisekunder.
|
|
|
Denne øvelses formål er at måle lyde på forskellige afstande, og aflæse dem på NXT brickens display. De lyde som vi måler er hhv. en sinuskurve, et klap og tale (“hej”) på afstande fra 0,5 m til 3 m. Vi fandt det yderst besværligt at aflæse disse værdier direkte fra displayet, da værdierne konstant ændrede sig. Vi forsøgte at imødekomme denne problematik ved at måle konstante lyde i stedet, såsom en sinuskurve, men også disse værdier viste sig at have store udsving.
|
|
|
|
|
|
Tabel 1: Tabel over målte værdier for forskellige lyde med tilhørende forskellige afstande.
|
|
|
Bemærk at vi foretager alle vores målinger i rå værdier, hvilket betyder at intervallet går fra 0-1023 - hvor 0 er en meget høj lyd og 1023 er en meget lav lyd.
|
|
|
|
|
|
|
|
|
Tabel 1: Tabel over målte værdier for forskellige lyde med tilhørende afstande
|
|
|
|
|
|
| Lyd | Afstand (ca.) | Måling |
|
|
|
| ------------- |:-------------:| -----:|
|
|
|
| Klap | | |
|
|
|
| Klap | | |
|
|
|
| Klap | | |
|
|
|
| Sinus Kurve | | |
|
|
|
| Sinus Kurve | | |
|
|
|
| Sinus Kurve | | |
|
|
|
|"Hallo" | | |
|
|
|
| "Hallo" | | |
|
|
|
| "Hallo" | | |
|
|
|
| Sinus Kurve | 0,5 m | 860 |
|
|
|
| Sinus Kurve | 1,0 m | 840 |
|
|
|
| Sinus Kurve | 1,5 m | 900 |
|
|
|
| Sinus Kurve | 2,0 m | 900 |
|
|
|
| Sinus Kurve | 2,5 m | 880 |
|
|
|
| Sinus Kurve | 3,0 m | 770 |
|
|
|
| Klap | 0,5 m | 782 |
|
|
|
| Klap | 1,0 m | 766 |
|
|
|
| Klap | 1,5 m | 740 |
|
|
|
| Klap | 2,0 m | 810 |
|
|
|
| Klap | 2,5 m | 900 |
|
|
|
| Klap | 3,0 m | 870 |
|
|
|
| “Hej” | 0,5 m | 780 |
|
|
|
| “Hej” | 1,0 m | 910 |
|
|
|
| “Hej” | 1,5 m | 890 |
|
|
|
| “Hej” | 2,0 m | 840 |
|
|
|
| “Hej” | 2,5 m | 770 |
|
|
|
| “Hej” | 3,0 m | 930 |
|
|
|
|
|
|
|
|
|
Resultatet af målingerne viser tydelige uhensigtsmæssigheden i manuelt at aflæse konstant ændrende værdier fra et display. Displayet opdatere ikke hurtigt nok til at få alle værdier med, dermed er der nogle potentielt essentielle værdier der kunne være blevet udeladt ved en kort lydfrekvens som f.eks. et klap. Vi tror dette kan forklare hvorfor der ikke umiddelbart er noget mønster i værdierne at analysere på, da selv et konstant lydniveau (som sinuskurven) viste den højeste lydmåling, på længste afstand. Vores konklusion af denne øvelse er derudaf, at det er nødvendigt med et værktøj til systematisk at indsamle det målte data. Vi analysere altså ikke dybdegående på disse data, fordi de umiddelbart er for påvirket af fejlkilderne.
|
|
|
|
|
|
### Exercise 2 - Data logger [2]
|
|
|
I denne exercise benyttede vi os af programmet Datalogger.java.
|
|
|
|
|
|
Vi udviklede og implementerede nedenstående sensor program, for at kunne udføre eksperimentet.
|
|
|
### Exercise 2 - Data logger [2]
|
|
|
I denne exercise benyttede vi os af klassen DataLogger til at indsamle sensordata om en række forskellige lyde, for at kunne analysere på disse og dermed kunne identificere bestemte lyde, såsom f.eks. et klap. Vi gennemfører tre forskellige eksperimenter, hhv. undersøger vi lydsensorens måling af klap, sinuskurve og tale over varierende afstande. Nedenfor ses den Java kode som blev brugt til at foretage og indsamle målingerne.
|
|
|
|
|
|
*Java kode 1: SoundSensorTest.java*
|
|
|
```Java
|
|
|
import lejos.nxt.*;
|
|
|
|
|
|
/**
|
|
|
* A simple sonar sensor test program.
|
|
|
*
|
|
|
* The sensor should be connected to port 1. In the known bugs and limitations
|
|
|
* of leJOS NXJ version alfa_03 it is mentioned that a gap of at least 300 msec
|
|
|
* is needed between calls of getDistance. This is the reason for the delay of
|
|
|
* 300 msec between sonar readings in the loop.
|
|
|
*
|
|
|
* @author Ole Caprani
|
|
|
* @version 30.08.07
|
|
|
*/
|
|
|
public class SoundSensorTest {
|
|
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
|
DataLogger dl = new DataLogger("Sound_3,0m.txt");
|
|
|
DataLogger dl = new DataLogger("Sound.txt");
|
|
|
|
|
|
SensorPort port = SensorPort.S1;
|
|
|
SoundSensor us = new SoundSensor(SensorPort.S1);
|
... | ... | @@ -83,69 +86,80 @@ public class SoundSensorTest { |
|
|
|
|
|
#### Eksperiment 1 - Testperson laver ét klap
|
|
|
|
|
|
*Billede 1: Opsætning af eksperiment 1.*
|
|
|
|
|
|
LEGO bilens lydsensor er placeret for enden af vores målestok (en lægte, hvorpå der er afmålt 30 cm - bemærk blyantstregen på billedet). Ved er står en person. Personen klapper én gang med samme styrke ved hver afstand.
|
|
|
*Billede 1: Opsætning af eksperiment 1*
|
|
|
|
|
|
![IMG_0590](http://gitlab.au.dk/uploads/group-5/group-5-lesson-3/2f8f499e54/IMG_0590.JPG)
|
|
|
|
|
|
Som set i Billed 1 er LEGO bilens lydsensor placeret for enden af vores målestok (en lægte, hvorpå der er afmålt 0,5 m med en linieal - bemærk blyantstregen i Billed 1). Ved første måling stillede en person sig 0,5 m fra lydsensoren og klappede, hvorefter personen flyttede målestokken (og sig selv) 0,5 m længere bagud og foretog endnu et klap. Dette fortsatte indtil personen nåede 3 m afstand fra lydsensoren. Det indsamlede data blev dernæst brugt til at lave grafen, der ses nedenfor. Grafen kan vi bruge til at analysere f.eks. lydmønsteret for et klap.
|
|
|
|
|
|
*Graf 1: Lydmålinger af klap ved forskellige afstande*
|
|
|
![klap](http://gitlab.au.dk/uploads/group-5/group-5-lesson-3/ab18378e55/klap.jpg)
|
|
|
|
|
|
Selve klappets natur er væsentligt at bemærke. Her er intervallet fra klappets begyndelse til klappets når maksniveau på ca. 15 ms (måling 2,5 m), mens intervallet fra klappets maksniveau til klappets slutning er på ca. 250 ms (måling 2,5 m). Dvs. klappet er utroligt hurtigt om at nå maksniveauet, hvorefter det aftager væsentligt langsommere, dvs. lyden “hænger” i lokalet efter klappet.
|
|
|
|
|
|
Overordnet, giver grafen et indtryk af at klappernes styrke aftager i takt med at afstanden forstørres, idet at det maksimale lydniveau for 2,5 m < 2 m < 1,5 m < 0,5 m. Ikke desto mindre lader det til at tendensen ødelægges af det maksimalt målte lydniveau på 3 m afstand, idet at målingen på 3 m er ca. det samme som ved 0,5 m - hvilket må attribueres til fejlkilder. Hvis vi ser bort fra 3 m anomalien, kan det maksimale lydniveau forstås til at falde med ca. 100 (rå værdi) for hver 0,5 m. I eksperimentet har vi del fejlkilder, bl.a. at det er tæt på umuligt at udføre et klap identisk ved hver måling. Herudover kan der være forekommet reflektion af klappe lyden på rummets vægge ift. afstanden, hvilket kan give fejlbehæftede målinger. Opsummeret så er der altså en tydelig sammenhæng mellem det maksimale lydniveau for et klap og den afstanden mellem lydsensoren og klappet.
|
|
|
|
|
|
#### Eksperiment 2 - Computer afspiller sinus kurve - 500hZ
|
|
|
|
|
|
#### Eksperiment 2 - Computer afspiller sinuskurve - 500 Hz
|
|
|
|
|
|
*Billede 2: Opsætning af eksperiment 2.*
|
|
|
|
|
|
![IMG_0592](http://gitlab.au.dk/uploads/group-5/group-5-lesson-3/c6c66fbc29/IMG_0592.JPG)
|
|
|
|
|
|
Bemærk at computerens højtaler er placeret ud fra den afmålte 30 cm streg.
|
|
|
I denne opsætning placeres en computer på en stol, med dens højtaler placeret ud for lægtens 0,5 m afstandsafmærkning. Ligeledes eksperiment 1 bliver afstanden, mellem computerens højttaler og LEGO bilens lydsensor, herefter øget gradvist med 0,5 m for hver ny måling. Data indsamlet ved dette eksperiment kan ses i grafen nedenfor.
|
|
|
|
|
|
*Graf 2: Lydmålinger af sinuskurve ved forskellige afstande*
|
|
|
![sinus](http://gitlab.au.dk/uploads/group-5/group-5-lesson-3/172b62fc51/sinus.jpg)
|
|
|
|
|
|
Dette eksperiment viser forventeligt et mindre antal markante udsving end Graf 1, da sinus lyd kurven er konsistent, konstant og frembragt af en computer. Hvad der dog er ganske interessant med målingerne er at det maksimalt målte lydniveau ikke lader til at aftage betragtelig med afstanden, f.eks. er målingerne ved 3 m kraftigere end ved 1 m. Vi er usikre på hvorfor dette sker, men det er muligt at sinuskurver simpelthen fremstår mere unuanceret for lydsensoren. Ligesom i det forrige eksperiment er der også mulighed for en del fejlkilder såsom at lokalet, hvori målingerne blev optaget reflekterer lyden.
|
|
|
|
|
|
|
|
|
#### Eksperiment 3 - Testperson siger "Hallo"
|
|
|
#### Eksperiment 3 - Testperson siger "hej"
|
|
|
|
|
|
*Billede 3: Opsætning af eksperiment 3.*
|
|
|
|
|
|
![IMG_0593](http://gitlab.au.dk/uploads/group-5/group-5-lesson-3/5eab1b261f/IMG_0593.JPG)
|
|
|
|
|
|
*Graf 3: Lydmålinger af "Hallo" ved forskellige afstande*
|
|
|
Denne opsætning er meget lig med eksperiments 1 opsætning, da testpersonen igen placeres med 0,5 meters afstand til lydsensoren. Men frem for at klappe, taler personen i stedet. Personen skal forsøge at sige “hej” med samme tonefald og toneleje. Lyden er derfor forventelig heller ikke et konstant lydniveau som i eksperiment 2. De indsamlede målinger fra eksperimentet kan ses i grafen nedenfor.
|
|
|
|
|
|
*Graf 3: Lydmålinger af "Hej" ved forskellige afstande*
|
|
|
![hallo](http://gitlab.au.dk/uploads/group-5/group-5-lesson-3/4e5913bc94/hallo.jpg)
|
|
|
|
|
|
Selve naturen af de enkelte målinger er lige så Eksperiment 1 også værd at bemærke her. I forhold til eksperiment 1 opfører lyden af en testperson der siger “Hej” sig væsentligt anderledes end et klap. Ved ligeså at tage udgangspunkt i målingen for 2,5 m ses det at intervallet for lydens begyndelse til lydens maksimale måling er ca. 100 ms er væsentligt større end start intervallet for et klap (ca. 15 ms). Ord er dermed langsommere lyde, der har længere om at nå deres maksniveau end hurtige intense lyde, såsom klap.
|
|
|
|
|
|
Overordnet giver grafen et indblik i udfordringerne ved lydmålingerne på forskellige afstande med ikke-konstante lydniveauer. Udsvingende viser ikke, i sig selv, noget tydeligt mønster for en aftagning i lyd, ved forøget afstand, da “Hej” eksempelvis ved 0,5 m gav omtrent det samme udsving som ved 2 m. Fejlkilder for dette er, tilsvarende eksperiment 1, grundet i problematikken om at man ikke kan sige “Hej” flere gange fuldstændig identisk.
|
|
|
|
|
|
|
|
|
### Exercise 3 - Sound Controlled Car
|
|
|
|
|
|
I denne exercise eksperimenteres der lydsensoren gennem programmet SoundCtrCar.java. Programmet anvender klassen Car.java til at bevæge sig frem, til højre og til venstre når lydsensoren registrerer en høj lyd f.eks. et klap fra omgivelserne.
|
|
|
I denne øvelse eksperimenteres der med lydsensoren med programmet SoundCtrCar.java. Programmet anvender klassen Car.java til at bevæge sig frem, til højre, til venstre og stoppe. Video 1 viser en demonstration af LEGO-bilens opførsel.
|
|
|
|
|
|
*Video 1: Demonstration af LEGO-bilens opførsel ved afvikling af programmet SoundCtrCar.java*
|
|
|
|
|
|
[![image alt text](http://img.youtube.com/vi/N2At1whIB3U/0.jpg)](http://www.youtube.com/watch?v=N2At1whIB3U)
|
|
|
|
|
|
Som det fremgår af videoen begynder bilen at køre ved første klap. Ved 2. klap registreres ikke af bilen, hvilket kan skyldes at klappet ikke sker tæt nok på bilen således, men ved 3. klap begynder bilen at dreje rundt om sig selv (mod højre). Ved 4. klap begynder bilen at dreje rundt om sig selv (mod venstre). Slutteligt, ved 5. klap standser bilen. Bortset fra det ene klap som bilen ikke registrerer har bilen nogenlunde samme reaktionshastighed ved alle klap.
|
|
|
Som det fremgår af videoen begynder bilen at køre fremad ved registrering af første klap. 2. klap registreres ikke af bilen, hvilket kan skyldes at klappet ikke er højt nok. Ved 3. klap begynder bilen at dreje rundt om sig selv (mod højre). Og ved 4. klap begynder bilen at dreje rundt om sig selv (mod venstre). Slutteligt, ved 5. klap, standser bilen. Bortset fra det 2. klap som bilen ikke registrerer, har bilen nogenlunde samme reaktionshastighed ved alle klap. Vi ser dermed at bevægelserne sker skiftevis i rækkefølgen: kør frem, drej til højre, drej til venstre, stop - og udløses når lydsensoren registrerer en høj lyd, som f.eks. et klap tilpas tæt på lydsensoren. I koden fra SoundCtrCar.java ses det at soundThreshold er sat til 90 (i dette program er lydmålinger angivet i % fremfor rå værdier). Denne værdi bliver brugt til at sammenligne med den sensor målte værdi soundLevel. Hvis soundLevel (sensor målingen) er større end soundThreshold, afvikles while-løkken med de forskellige kørselskonfigurationer for *fremad, højre, venstre og stop*. Dvs. LEGO-bilen kun udfører bevægelserne, hvis der måles en lyd over 90 %. Ligeså vil den først skifte videre fra et stadie (f.eks. drej til venstre) til et andet stadie når den hører en “høj” lyd over 90 %.
|
|
|
|
|
|
### Exercise 4 - ButtonListener
|
|
|
|
|
|
Programmet SoundCtrCar.java gør brug af forskellige slags løkker. Hvis programmet befinder sig i en indre løkke er det ikke muligt at afbryde programmet ved brug af ESCAPE knappen. I denne exercise er programmet modificeret, således at programmet også kan afbrydes i de indre løkker.
|
|
|
### Exercise 4 - ButtonListener
|
|
|
|
|
|
Som beskrevet i forrige exercise lytter LEGO-bilen efter høje lyde, som den derefter reagerer på ved at bevæge sig. Selve programmet SoundCtrCar.java benytter sig af metoden waitForLoudSound til dette. Når programmet når denne metode befinder det sig i en indre løkke, der ikke tillader at terminere programmet vha. NXT ESCAPE knap. Nedenstående video demonstrerer denne begrænsning.
|
|
|
|
|
|
*Video 2: SoundCtrCar.java demonstration uden program-Escape*
|
|
|
|
|
|
[![image alt text](http://img.youtube.com/vi/RkaFpe4X6Mc/0.jpg)](http://www.youtube.com/watch?v=RkaFpe4X6Mc)
|
|
|
|
|
|
Som det demonstreres i videoen er det ikke muligt at afbryde programmet ved brug af ESCAPE knappen. Dette skyldes at løkkerne i programmet blokerer for at trykket kan registreres, efter at lydsensoren har registreret lyden.
|
|
|
Som det demonstreres i videoen er det ikke muligt at afbryde programmet, mens det befinder sig i de indre løkker.
|
|
|
|
|
|
I denne øvelse har vi modificeret programmet SoundCtrCar.java, således at det altid kan termineres ved brug af ESCAPE knappen, også selvom programmet befinder sig i den indre while-løkke, der lytter efter høje lyde (>90%). Måden hvorpå vi har opnået dette er ved at implementere en buttonListener, som uafhængigt af while-løkken, lytter på om ESCAPE knappen trykkes, hvorved den terminerer programmet ved at køre System.exit(0).
|
|
|
|
|
|
|
|
|
*Java kode 2: Modificeret SoundCtrCar.java program, der tillader exit vha. ESCAPE knappen. *
|
|
|
|
|
|
```Java
|
|
|
import lejos.nxt.*;
|
|
|
import lejos.util.Delay;
|
|
|
|
|
|
/**
|
|
|
* The locomotions of a LEGO 9797 car is controlled by sound detected through a
|
|
|
* microphone on port 1.
|
|
|
*
|
|
|
* @author Ole Caprani
|
|
|
* @version 23.08.07
|
|
|
*/
|
|
|
public class SoundCtrCarFi {
|
|
|
private static int soundThreshold = 90;
|
|
|
private static SoundSensor sound = new SoundSensor(SensorPort.S1);
|
... | ... | @@ -208,28 +222,231 @@ public class SoundCtrCarFi { |
|
|
|
|
|
[![image alt text](http://img.youtube.com/vi/Qyjo4VAc5tE/0.jpg)](http://www.youtube.com/watch?v=Qyjo4VAc5tE)
|
|
|
|
|
|
Videoen demonstrerer at det er blevet muligt at afbryde programmet ved at trykke på ESCAPE knappen, selvom lydsensoren har registreret lyd.
|
|
|
Videoen ovenfor demonstrerer det modificerede program, som muliggør at afbryde programmet, selvom den indre while-løkke afvikles (i dette tilfælde under kørselskonfiguration *fremad*).
|
|
|
|
|
|
|
|
|
### Exercise 5 - Clap Controlled Car
|
|
|
|
|
|
>"A clap is a pattern that starts with a low-amplitude sample (say below 50), >followed by a very-high amplitude sample (say above 85) within 25 milliseconds, and >then returns back to low (below 50) within another 250 milliseconds." [3]
|
|
|
|
|
|
Inspireret af Sidan Toledo's ovenstående metode til at detektere klap, har vi udviklet og implementeret et program, der gør LEGO-bilen i stand til at detektere klap.
|
|
|
Inspireret af Sidan Toledo's ovenstående metode til at detektere klap, har vi udviklet og implementeret et program, der gør LEGO-bilen i stand til at detektere klap. Vores implementation forsøger at detektere et hurtigt spike i lydniveau, ved tage gennemsnittet for 8 af de 10 sidste målingerne (30 ms mellem hver måling) og sammenligne med gennemsnittet for de sidste 2 af de 10 målinger. Hvis forskellen mellem de 8 første og 2 sidste målinger er signifikant er vores første kriterie for et klap opfyldt. Vi venter dernæst 300 ms, og måler om lydniveauet er ambient igen - hvis dette er tilfældet er vores andet kriterium opfyldt, og vi har dermed detekteret et klap.
|
|
|
|
|
|
Java kode 3: Vores implementation af klap detektering (se repository for CyclicArray hvis nødvendigt)
|
|
|
|
|
|
´´´Java
|
|
|
import lejos.nxt.*;
|
|
|
import lejos.util.Delay;
|
|
|
|
|
|
public class ClapCtrCar implements ButtonListener {
|
|
|
|
|
|
private static final int CLAP_SAMPLE_RATE = 30; // Hastigheden hvorved vi ser ud i verden
|
|
|
private static final int AMBIENT_SOUND = 925; // Normalt lyd niveau
|
|
|
private static final int CLAP_MAGIC = 700; // Mininum lyd niveau for et klap
|
|
|
private static final int CLAP_FALLDOWN_DELAY = 300; // Tiden det tager for et klap at fade
|
|
|
|
|
|
private static SensorPort soundPort = SensorPort.S1;
|
|
|
|
|
|
private static CyclicArray soundMemory = new CyclicArray(10);
|
|
|
|
|
|
private static void waitForClapSound() throws Exception {
|
|
|
soundMemory.clear(AMBIENT_SOUND);
|
|
|
|
|
|
while (true) {
|
|
|
int soundLevel = soundPort.readRawValue();
|
|
|
soundMemory.add(soundLevel);
|
|
|
|
|
|
double oldMemory = soundMemory.average(0, 8);
|
|
|
double newMemory = soundMemory.average(8, 2);
|
|
|
|
|
|
LCD.drawInt(soundLevel, 4, 10, 0);
|
|
|
LCD.drawInt((int)oldMemory, 4, 10, 2);
|
|
|
LCD.drawInt((int)newMemory, 4, 10, 4);
|
|
|
|
|
|
if(oldMemory > AMBIENT_SOUND && newMemory < CLAP_MAGIC) {
|
|
|
Delay.msDelay(CLAP_FALLDOWN_DELAY);
|
|
|
|
|
|
if(soundPort.readRawValue() > AMBIENT_SOUND) {
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
soundMemory.clear(AMBIENT_SOUND);
|
|
|
}
|
|
|
|
|
|
Delay.msDelay(CLAP_SAMPLE_RATE);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
|
soundPort.setTypeAndMode(SensorConstants.TYPE_SOUND_DB, SensorConstants.MODE_PCTFULLSCALE);
|
|
|
|
|
|
new ClapCtrCar();
|
|
|
}
|
|
|
|
|
|
public ClapCtrCar() throws Exception {
|
|
|
Button.ESCAPE.addButtonListener(this);
|
|
|
|
|
|
LCD.drawString("dB level: ", 0, 0);
|
|
|
LCD.refresh();
|
|
|
|
|
|
while (true) {
|
|
|
waitForClapSound();
|
|
|
Sound.buzz();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
public void buttonPressed(Button b) {
|
|
|
// TODO Auto-generated method stub
|
|
|
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
public void buttonReleased(Button b) {
|
|
|
Car.stop();
|
|
|
LCD.clear();
|
|
|
LCD.drawString("Program stopped", 0, 0);
|
|
|
Delay.msDelay(2000);
|
|
|
System.exit(0);
|
|
|
}
|
|
|
}
|
|
|
´´´
|
|
|
|
|
|
[Kode mangler - indsæt evt. snippets her, og koden som repository]
|
|
|
*Video 4: Demonstration af vores LEGO bil med ClapCtrCar programmet kørerende*
|
|
|
|
|
|
[![image alt text](http://img.youtube.com/vi/7juN0hhtsNo/0.jpg)](http://www.youtube.com/watch?v=7juN0hhtsNo)
|
|
|
|
|
|
Vores implementation er dog ikke fejlfri - i implementationen af dette program har vi lært at det er ganske svært at registrerer bestemte lyde konsistent, såsom et klap - fordi lyde varierer betragtelig i udtryk ift. bl.a. afstand og rum. Men vi formoder at der laves en del forbedringer af vores nuværende implementation, da der visse gange opstår en fejlregistrering af klap. Endvidere er rækkevidden på detektering af klap i den nuværende implementation relativt begrænset til omkring 1-1,5 m, hvilket formentlig også kan forbedres med finjustering.
|
|
|
|
|
|
|
|
|
### Exercise 6 - Party Finder Robot
|
|
|
|
|
|
I denne exercise påmonteres to lydsensorer på LEGO-bilen. Formålet med øvelsen er at bruge målingerne fra de to sensorer til at få bilen til at køre imod lyden - og dermed finde festen.
|
|
|
Målet med denne øvelse er at få LEGO bilen til at finde en fest (dvs. køre hen til det sted med mest larm). For at opnå dette har vi monteret 2 lydsensorer på LEGO bilen, således vi kan kan detektere lyd i forskellige retninger (hhv. højre og venstre). Lydsensorene blev placeret således de pegede væk fra LEGO-bilen i ca. 75 graders vinkel (se billede 4), for at gøre differencen mellem de to sensorer størst muligt - så vi nemmere kan skelne mellem lyde fra højre og venstre side. Herudover brugte vi plastikkopper som paraboler på lydsensorerne, for nemmere at kunne opfange lydkilder på afstand.
|
|
|
|
|
|
*Billede 4: Placering og modificering af de to lydsensorer på LEGO-bilen.*
|
|
|
|
|
|
[IMG_0627](http://gitlab.au.dk/uploads/group-5/group-5-lesson-3/f966f61af6/IMG_0627.JPG)
|
|
|
|
|
|
Vores implementation har, tilsvarende SoundCtrCar.java, nogle states, hvor lydniveauet og retningen af lyd afgør hvilket state programmet befinder sig i. Initialt observerede vi at LEGO-bilens egen motor havde en stor indflydelse på de lydmålinger den foretog, hvorfor vores implementation gør brug af et “Listen”-state, hvor bilen holder stille, lytter og vurderer om den skal dreje til venstre, højre, køre ligeud eller holde stille og lytte indtil der kommer en lyd. På baggrund af de store udsving i målingerne gør koden brug af et cyclic array, der konstant opdateres med de seneste 3 lydmålinger for hver sensor, hvor gennemsnittet af disse målinger bruges til at determinere i hvilken retning lydniveauet er højest. Foruden dette, tager koden højde for, ikke at reagere på ambient lyd eller stille snak, og at differencen i gennemsnittet af målingerne på de 2 sensorer skal være større end et threshold på 15 (rå værdi), før den drejer til enten højre eller venstre. Hvor lang tid den kører fremad, samt hvor lang tid der drejes, er konstant, før den igen sættes i Listen-state. I den nuværende implementation køres fremad i 1 s, før der igen vurderes om der skal ændres retning.
|
|
|
|
|
|
´´´Java
|
|
|
import lejos.nxt.Button;
|
|
|
import lejos.nxt.LCD;
|
|
|
import lejos.nxt.SensorConstants;
|
|
|
import lejos.nxt.SensorPort;
|
|
|
import lejos.nxt.UltrasonicSensor;
|
|
|
import lejos.util.Delay;
|
|
|
import static java.lang.Math.*;
|
|
|
|
|
|
public class PartyFinder2 {
|
|
|
|
|
|
enum State {
|
|
|
Listen,
|
|
|
TurnLeft,
|
|
|
TurnRight,
|
|
|
MoveForward,
|
|
|
}
|
|
|
|
|
|
private static State state = State.Listen;
|
|
|
|
|
|
private static int AMBIENT_SOUND = 920;
|
|
|
|
|
|
private static int minPower = 65;
|
|
|
|
|
|
private static CyclicArray leftSoundMemory = new CyclicArray(3);
|
|
|
private static CyclicArray rightSoundMemory = new CyclicArray(3);
|
|
|
|
|
|
private static int listenTimer = 0;
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
SensorPort leftSoundPort = SensorPort.S1;
|
|
|
SensorPort rightSoundPort = SensorPort.S2;
|
|
|
|
|
|
leftSoundPort.setTypeAndMode(SensorConstants.TYPE_SOUND_DB, SensorConstants.MODE_PCTFULLSCALE);
|
|
|
rightSoundPort.setTypeAndMode(SensorConstants.TYPE_SOUND_DB, SensorConstants.MODE_PCTFULLSCALE);
|
|
|
|
|
|
while (!Button.ESCAPE.isDown()) {
|
|
|
leftSoundMemory.add(leftSoundPort.readRawValue());
|
|
|
rightSoundMemory.add(rightSoundPort.readRawValue());
|
|
|
|
|
|
switch(state) {
|
|
|
case Listen:
|
|
|
double leftSound = leftSoundMemory.average(0, 3);
|
|
|
double rightSound = rightSoundMemory.average(0, 3);
|
|
|
|
|
|
LCD.drawInt((int) leftSound, 4, 10, 2);
|
|
|
LCD.drawInt((int) rightSound, 4, 10, 4);
|
|
|
|
|
|
listenTimer++;
|
|
|
if(listenTimer < 10) {
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
if(leftSound < AMBIENT_SOUND && rightSound < AMBIENT_SOUND) {
|
|
|
double diff = abs(leftSound - rightSound);
|
|
|
|
|
|
if(diff > 15) {
|
|
|
if(leftSound > rightSound) {
|
|
|
state = State.TurnLeft;
|
|
|
} else {
|
|
|
state = State.TurnRight;
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
state = State.MoveForward;
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
case MoveForward:
|
|
|
Car.forward(minPower, minPower);
|
|
|
Delay.msDelay(1000);
|
|
|
Car.stop();
|
|
|
Delay.msDelay(100);
|
|
|
state = State.Listen;
|
|
|
listenTimer = 0;
|
|
|
break;
|
|
|
case TurnLeft:
|
|
|
Car.rotateLeft(minPower);
|
|
|
Delay.msDelay(250);
|
|
|
Car.stop();
|
|
|
Delay.msDelay(100);
|
|
|
state = State.Listen;
|
|
|
listenTimer = 0;
|
|
|
break;
|
|
|
case TurnRight:
|
|
|
Car.rotateRight(minPower);
|
|
|
Delay.msDelay(250);
|
|
|
Car.stop();
|
|
|
Delay.msDelay(100);
|
|
|
state = State.Listen;
|
|
|
listenTimer = 0;
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
Delay.msDelay(5);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
´´´
|
|
|
|
|
|
Gennem kalibrering af programmet fandt vi ud af at det var fordelagtigt at placere en plastikkop omkring hver lydsensor, for på denne måde at gøre det lettere for programmet at differentiere imellem de 2 lydsensorers målinger. Et trade-off heraf, gjorde det dog en anelse sværere, for programmet, at bedømme hvornår der skulle køres ligeud, dog blev dette til dels udbredte ved at vi forøgede minimum-differencen i målingerne, til at være 15, hvor den ved alt under dette, kører ligeud.
|
|
|
|
|
|
I nedenstående videoer demonstreres en testkørsel af programmet PartyFinder.java med to forskellige “targets” - fester: 1) Et stillestående target, i form af en computer der afspiller høj larmende musik (dødsmetal). 2) Et target der bevæger sig, i form af en testperson der fører en smartphone, der afspiller musik, rundt om LEGO-bilen.
|
|
|
|
|
|
*Video 5: Demonstration af testkørsel af PartyFinder.java - med stillestående fest*
|
|
|
[![image alt text](http://img.youtube.com/vi/Dw9jAxBqO5A/0.jpg)](http://www.youtube.com/watch?v=Dw9jAxBqO5A)
|
|
|
|
|
|
*Video 6: Demonstration af testkørsel af PartyFinder.java - med fest der flytter sig*
|
|
|
[![image alt text](http://img.youtube.com/vi/TVj_OLnE25M/0.jpg)](http://www.youtube.com/watch?v=TVj_OLnE25M)
|
|
|
|
|
|
Vores implementation er uden tvivl ikke perfekt, da LEGO-bilen ofte køre i blinde (f.eks. 1 s når den køre fremad). Herudover har den svært ved at registrer larm bagved sig. Årsagen til at den ofte køre i blinde er fordi den nuværende løsning i høj grad afhænger af delays for at undgå motorlyd. Disse delays betyder at bilens responsivitet er stærkt begrænset og det er sværere for den at korrigere fejl.
|
|
|
|
|
|
[Kode mangler - indsæt evt. snippets her, og koden som repository]
|
|
|
|
|
|
Koden tager højde for at sensorerne ikke måler ens værdier.
|
|
|
## Conclusion
|
|
|
|
|
|
Alle eksperimenter er blevet udført ved brug af guiden for Lesson 3 [1].
|
|
|
Alle øvelser er blevet udført i henhold til instruktionerne fra NXT guiden for Lesson 3 [1]. Gennem forskellige eksperimenter med sensoren har vi fået erfaring med NXT lydsensoren, og dermed opnået en bedre forståelse for anvendelsesrammen for lydsensoren.
|
|
|
|
|
|
Vi har vist at lydsensoren er i stand til at registrere værdier for forskellige lyde indenfor 3 meters rækkevidde. Derudover har vi, ved hjælp af datalogning, påvist at eksempelvis en sinuskurve har en lydprofil der er vidt forskellig fra talte ord (eks. “Hej”), hvilket gør det muligt at differentiere mellem lyde. Men vi må også erkende at det fysiske miljø spiller en stor rolle for troværdigheden af målingerne, da akustiske faktorer i særdeleshed kan påvirke målingerne. Ved at karakterisere disse lydprofiler, på samme måde som Toledo f.eks. karakteriserer et klap, kan man lave programmer der gør LEGO-bilen i stand til at registrere klap og handle derefter. På denne måde kan man anvende lyd som input for bilens bevægelsesmønster, og eksempelvis få den den til at bevæge sig frem, til siden og stoppe. Ved yderligere påmontering af to lydsensorer har vi vist at LEGO-bilen kan bruge differencen mellem de to lydsensores målte værdier til at navigere efter høje lyde, og dermed fysisk bestemme en lydkilde. Det er dog langt fra simpelt at kalibrere programmet til at virke perfekt hver gang.
|
|
|
|
|
|
|
|
|
## References
|
|
|
|
... | ... | @@ -237,4 +454,4 @@ Alle eksperimenter er blevet udført ved brug af guiden for Lesson 3 [1]. |
|
|
|
|
|
[2] Data Logger - http://en.wikipedia.org/wiki/Data_logger
|
|
|
|
|
|
[3], Sivan Toledo, A Clap Counter, Oct 2006. |
|
|
\ No newline at end of file |
|
|
[3] Sivan Toledo, A Clap Counter, Oct 2006. |