Ideen her er at opbygge en bærbar virtuel guitar, der skal styres med to hænder, ligesom at spille Air Guitar. Det er blevet oprettet og prototyperet i løbet af et to uger projekt på
Målet er at få følelsen af at spille en ægte guitar. AIRduino Guitar er lavet af en handske og en pind.Handsken bruges til at indstille tonen og stangen til at udløse lyden.
For at udføre et sådant trick anvendte vi et accelerometer og en ultraljudssensor (se trin 1 for konceptbeskrivelse).
Tag et kig på video demoen for at få en mere præcis ide om, hvordan det virker, og komme i gang med at bygge din egen!
AIRduino-holdet:
David Fournier, Jean-Louis Giordano, Monireh Sanaei, Maziar Shelbaf og Gustav Sohtell.
forsyninger:
Trin 1: Konceptbeskrivelse
Luftguiten skal fungere som højrehåndet guitar.
Guitarcontrolleren er opdelt i to dele, venstre styring og højre håndregulator.
Ved venstre styring kan spilleren bøje fingrene og trykke på handsken for at ændre tonehøjden.
Den højre håndregulator er repræsenteret af en pind, der skal rystes for at udløse lyden fra guitaren.
Spilleren kan også ændre afstanden mellem højre hånd og venstre hånd for at tonehøjde tonerne, simulere de forskellige frets på guitar halsen.
For at udføre sådanne tricks er hovedkomponenterne et accelerometer til at "føle" stokskakningen, en hacket ultraljudssensor til måling af afstanden mellem højre hånd og staven og ledende stof til at opbygge handsken.
Alt i alt er det en temmelig let at bygge legetøj. Den eneste vanskelige del ville være den ultraljudiske sensorhak, der kræver en vis fingerfærdighed. Du skal bruge nogle grundlæggende elektroniske færdigheder til at forstå instruktionerne, og også for at finde ud af, hvad du gjorde forkert, når du rodede noget op og gitaren virker ikke i sidste ende. Vi har været der. :-)
Trin 2: Indkøbsliste
Her er en liste over, hvad du behøver for at opbygge din egen AIRduino Guitar:
1. Ledninger: Desværre meget for denne prototype version. De har været brugt til at forbinde de to handsker og Arduino dele sammen. Du er velkommen til at forbedre denne del af designet ved at gøre det trådløst!
2. Accelerometer: Anvendes i stokken i din højre hånd for at registrere rystningen. Vi brugte et treakse accelerometer, men en enakse er nok
3. Ultralyd sensor: bruges til at måle afstanden mellem begge hænder af afspilleren, vi brugte Parallax # 28015
4. Ledende og Stretch stof: at opbygge handsken,
5. Arduino: kernen af guitaren, der håndterer alt. En Arduino Diecimila fungerer fint.
6. Potentiometre: For at justere nogle indstillinger, er et potentiometer med et maksimum på alt fra 1KOhm-1MOhm ok.
7. Hot melt lim: en bekvem måde at holde tingene sammen,
8. 3,5 mm female jack: bruges til lydudgang,
9. Klassiske elektroniske ting: Modstande (10k), kondensator (10uF), lysdioder og en slags strømforsyning til arduino. (Et 9V batteri er bare fint).
Trin 3: Skemaer
Her er de elektroniske skemaer til AIRduino Guitar.
Som du kan se, er det ret nemt at forstå og derfor også at bygge.
Se på billedet, hvis du vil have en ide om, hvilken komponent der går. Som du sikkert forstår, er det nej at skalere på nogen måde. Kablerne er meget længere end vist i skematisk.
Du har måske også bemærket, at ultraljudsensorens sender er på pinden, og modtageren er på venstre hånd. Det er den vanskelige del, jeg tidligere har nævnt: Du skal løsne ultraljudsenderen fra ultraljudsenderen for at adskille den fra sensorkortet.
Mere om det i senere trin. Lad os nu komme til at arbejde!
Trin 4: Opbygning af handsken
Handsken indeholder en ultraljudsmodtager og fire knapper. Det er det!
Den ultraljudiske modtager er placeret i den sorte boks, der er synlig på nogle af nedenstående billeder.
Handsken har et stort område, der netop er forbundet med jorden på Arduino bordet. Når en finger presses mod håndfladen, oprettes der en forbindelse mellem det ledende stof på fingeren og håndfladen.
Nedenfor ses et billede af to forskellige handskemodeller. Man har aftagelige fingre, som giver begge spillere meget små og meget store hænder. Den anden model syes direkte på en standardhandske. Jeg vil anbefale den anden version, det er lettere at bygge, og lettere at sætte på.
Trin 5: Kode
Her kræves Arduino-koden:
Real-time lyd generation del er taget fra denne fantastiske tutorial.
------------------------------------------------------
// Et array indeholdende bølgeformen
// af en guitar lyd
char bølgeform =
{125, 148, 171, 194, 209, 230, 252, 255,
253, 244, 235, 223, 207, 184, 169, 167,
163, 158, 146, 131, 126, 129, 134, 127,
105, 80, 58, 51,38, 22, 12, 2, 10, 35,
58, 75, 89, 103, 120, 141, 150, 148, 145,
144, 140, 129, 116, 105, 95, 86, 75, 72,
73, 76, 88, 103, 117, 121, 120, 115, 120,
143, 159, 162, 156, 155, 163, 184, 202,
214, 215, 211, 213, 212, 205, 196, 182,
162, 142, 118, 99, 84, 68, 54, 40, 28,
19, 10, 7, 0, 0, 5, 9, 14, 21, 33,
49, 59, 65, 75, 92, 110};
// Vi bruger denne bølgeform til at ændre
// volumen af udgangen
char waveformVolume =
{125, 148, 171, 194, 209, 230, 252, 255,
253, 244, 235, 223, 207, 184, 169, 167,
163, 158, 146, 131, 126, 129, 134, 127,
105, 80, 58, 51,38, 22, 12, 2, 10, 35,
58, 75, 89, 103, 120, 141, 150, 148, 145,
144, 140, 129, 116, 105, 95, 86, 75, 72,
73, 76, 88, 103, 117, 121, 120, 115, 120,
143, 159, 162, 156, 155, 163, 184, 202,
214, 215, 211, 213, 212, 205, 196, 182,
162, 142, 118, 99, 84, 68, 54, 40, 28,
19, 10, 7, 0, 0, 5, 9, 14, 21, 33,
49, 59, 65, 75, 92, 110};
// Et array bruges som buffer for at undgå
// Fejlagtig punktlig afstand
// målinger
usigneret int distance_buffer = {16000,
16000, 16000, 16000, 16000, 16000, 16000,
16000, 16000, 16000, 16000, 16000, 16000,
16000, 16000, 16000};
const int distance_length = 3;
int distance_index = 0;
// Overløbsværdierne for 2 oktaver
int frekvenser = {39, 42, 44, 47,
50, 52, 56, 59, 63, 66, 70, 74, 79,
84, 89, 94, 100, 105, 112, 118, 126,
133, 141, 149};
// Indledende tonehøjde
int pitch = 160;
// Indledende volumen og acceleration
// parameter
int sidsteAcc = 0;
flydevolumen = 0;
// lydafspilning på pin 3
byte speakerpin = 3;
// indeksvariabel for position i
// bølgeform
flygtige byte waveindex = 0
volatile byte currentvalue = 0;
// Pin bruges til ultrasonisk sensor
const int pingPin = 7;
// Pins til potentiometrene
const int sustainPin = 1;
const int følsomhedPin = 2;
// Pins for hver finger fra venstre
// hånd
const int finger1 = 9;
const int finger2 = 10;
const int finger3 = 11;
const int finger4 = 12;
int fingerValue = 0;
lang varighed, tommer, cm;
void setup () {
pinMode (3, OUTPUT); // Højttaler på pin 3
pinMode (finger1, INPUT);
pinMode (finger2, INPUT);
pinMode (finger3, INPUT);
pinMode (finger4, INPUT);
/**************************
PWM lydkonfiguration
****************************/
// Indstil Timer2 til hurtig PWM-tilstand
// (dobbelt PWM-frekvens)
bitSet (TCCR2A, WGM21);
bitSet (TCCR2B, CS20);
bitClear (TCCR2B, CS21);
bitClear (TCCR2B, CS22);
// muliggør afbrydelser nu, at registre
// er blevet indstillet
sei ();
/*************************
Timer 1 afbryder konfiguration
*************************/
// deaktiver interrupts mens
// registre er konfigureret
cli ();
/ * Normal portdrift, stifter frakoblet
fra timeroperation (breaking pwm) * /
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);
/ * Mode 4, CTC med TOP sæt ved register
OCR1A. Tillader os at indstille variabel timing for
afbrydelsen ved at skrive nye værdier til
OCR1A. * /
bitClear (TCCR1A, WGM10);
bitClear (TCCR1A, WGM11);
bitSet (TCCR1B, WGM12);
bitClear (TCCR1B, WGM13);
/ * Indstil klokkens prescaler til / 8. * /
bitClear (TCCR1B, CS10);
bitSet (TCCR1B, CS11);
bitClear (TCCR1B, CS12);
/ * Deaktiver Force Output Sammenlign for
Kanaler A og B. * /
bitClear (TCCR1C, FOC1A);
bitClear (TCCR1C, FOC1B);
/ * Initialiserer Output Sammenlign
Registrer A ved 160 for at indstille
indledende tonehøjde * /
OCR1A = 160;
// deaktiver input capture interrupt
bitClear (TIMSK1, ICIE1);
// deaktiver Output
// Sammenlign B Match Afbryd
bitClear (TIMSK1, OCIE1B);
// Aktiver Output
// Sammenlign en kampafbrydelse
bitSet (TIMSK1, OCIE1A);
// deaktiver Overflow Interrupt
bitClear (TIMSK1, TOIE1);
// gør det muligt at afbryde det nu
// registreringer er blevet indstillet
sei ();
}
// Timer overløbshåndterer
ISR (TIMER1_COMPA_vect) {
/ * timer1 ISR. Hver gang det
hedder det sætter højttalerpind til
næste værdi i bølgeform . Frekvens
Modulation sker ved at ændre
timing mellem successive opkald af
denne funktion, f.eks. for en 1KHz tone,
Indstil timingen, så den kører
gennem bølgeform 1000 gange
et sekund. * /
// reset waveindex, hvis det er nået
// slutningen af arrayet
hvis (waveindex> 102) {
bølgeindeks = 0;
}
// Indstil output værdi
hvis (volumen> 0,03) {
analogWrite (speakerpin,
waveformVolume waveindex);
}
waveindex ++;
// Opdater tonehøjde
OCR1A = tonehøjde;
}
void loop ()
{
// Desaktivér interputs, send en ping
// besked og vent på svaret.
cli ();
pinMode (pingPin, OUTPUT);
digitalWrite (pingPin, LOW);
delayMicroseconds (2);
digitalWrite (pingPin, HIGH);
delayMicroseconds (5);
digitalWrite (pingPin, LOW);
varighed = pulsIn (pingPin, HIGH, 2000);
sei ();
// konvertere tiden til en afstand
// i centimeter
// og gemme i buffer
distance_buffer distance_index ++
% distance_length = duration / 20;
// Find i buffer den korteste
// afstand målt
cm = 16000;
for (int i = 0; i <distance_length; i ++) {
cm = min (cm, distance_buffer i);
}
// Kontroller, hvilke fingre der trykkes på
fingerValue = 5;
if (! DigitalLæs (finger4)) {
fingerValue = 4;
}
if (! DigitalLæs (finger3)) {
fingerValue = 3;
}
if (! DigitalLæs (finger2)) {
fingerValue = 2;
}
if (! DigitalLæs (finger1)) {
fingerValue = 1;
}
// Opdatér sustain og
// følsomhedsværdier
float sustain =
kort (analogRead (sustainPin), 0,
1024, 101, 130) / 100.0;
int følsomhed =
kortet (analogRead (sensitivityPin),
0, 1024, 100, 200);
// Opdater lydstyrken
volumen = volumen / holdbarhed;
hvis (volumen <0) {
volumen = 0;
}
// Kontroller accelerometeret
int acc = analogRead (0);
int accDiff = lastAcc - acc;
// Opdater volumenværdien
hvis (accDiff> 5 * (200 - følsomhed)) {
volumen + = (flyde)
pow (accDiff,
følsomhed / 100,0) / 50000;
}
lastAcc = acc;
// Kontroller, at lydstyrken ikke er højere end 1
hvis (volumen> .95) {
volumen = .95;
}
// Opdater volumenet i bølgeformen
for (int i = 0; i <= 102; i ++) {
bølgeformVolume i =
((bølgeform i - 127) * volumen) + 127;
}
// Indstil tonehøjden efter afstanden
// mellem de to hænder og
// tryk på fingrene
hvis (cm <102 && cm> 0) {
hvis (cm> 30) {
tonehøjde = frekvenser 7 +
(((cm - 30) / 24) * 4 + fingerValue - 1);
}andet{
tonehøjde = kort (cm, 0, 30, 39, 79);
}
}andet{
tonehøjde = frekvenser 7 +
(((102 - 30) / 24) * 4 + fingerValue - 1);
}
// Forsinkelse for at undgå hoppende signaler
forsinkelse (50);
}
------------------------------------------------------
