Ideea aici este de a construi o chitara virtuala purtata, care trebuie sa fie controlata cu doua maini asemanatoare cu cea a lui Air Guitar. Acesta a fost creat și prototipat pe parcursul unui proiect de două săptămâni la
Scopul este de a avea sentimentul de a juca o chitara adevarata. Chitara AIRduino este fabricată dintr-o mănușă și un stick.Manusa este utilizata pentru a seta tonul si stick-ul pentru a declansa sunetul.
Pentru a efectua un astfel de truc, am folosit un accelerometru și un senzor ultrasonic (vezi Pasul 1 pentru descrierea conceptului).
Aruncați o privire la demo-ul video pentru a obține o idee mai precisă despre modul în care funcționează și ajungeți la lucru pentru a vă construi propriul!
Echipa AIRduino:
David Fournier, Jean-Louis Giordano, Monireh Sanaei, Maziar Shelbaf și Gustav Sohtell.
Furnituri:
Pasul 1: Descrierea conceptului
Chitara aerului ar trebui să funcționeze ca o chitară dreaptă.
Controlerul de chitară este împărțit în două părți, controlerul stâng și controlerul din dreapta.
Prin controlerul stâng, jucătorul își poate îndoi degetele și apasă mănușa pentru a schimba tonul tonului.
Controlerul din partea dreaptă este reprezentat de un baston care trebuie să fie agitat pentru a declanșa sunetul chitarei.
Jucătorul poate, de asemenea, să schimbe distanța dintre mâna dreaptă și cea stângă, pentru a răsfoi tonurile, simulând diferitele freturi pe gâtul chitarei.
Pentru a efectua astfel de trucuri, componentele principale sunt un accelerometru care "simte" agitația bățului, un senzor ultrasonic hacked pentru a măsura distanța dintre mâna dreaptă și stick și țesătura conductivă pentru a construi mănușa.
În general, este destul de ușor să construiești o jucărie. Singura parte complicată ar fi hack-ul senzorului ultra-sonic care necesită o anumită dexteritate. Veți avea nevoie de niște abilități electronice de bază pentru a înțelege instrucțiunile și, de asemenea, pentru a afla ce ați făcut greșit atunci când ați bătut ceva și chitara nu funcționează în cele din urmă. Am fost acolo. :-)
Pasul 2: Lista de cumpărături
Iată o listă a ceea ce aveți nevoie pentru a vă construi propriul AIRduino Guitar:
1. Firuri: din păcate, mult pentru această versiune prototip. Acestea au fost utilizate pentru a conecta cele două mănuși și piesele Arduino împreună. Simțiți-vă liber să îmbunătățiți această parte a designului făcându-l fără fir!
2. Accelerometru: utilizat în bastonul din mâna ta dreaptă pentru a detecta tremuratul. Am folosit un accelerometru cu trei axe, dar o singură axă este suficientă
3. Senzor ultrasonic: utilizat pentru a măsura distanța dintre ambele mâini ale playerului, am folosit Parallax # 28015
4. Tesatura conductivă și Stretch: pentru a construi mănușa,
5. Arduino: nucleul chitarului care manipulează totul. Un Arduino Diecimila funcționează bine.
6. Potențiometre: pentru a regla unele setări, un potențiometru cu o valoare maximă de la 1KOhm-1MOhm este ok.
7. Adeziv topit: un mod convenabil de a ține lucrurile împreună,
8. Mufă mamă 3,5 mm: utilizată pentru ieșirea audio,
9. Materiale electronice clasice: Rezistori (10k), condensatori (10uF), LED-uri și un fel de sursă de alimentare pentru arduino. (O baterie de 9V este bine).
Pasul 3: Schema
Iată schemele electronice ale chitarei AIRduino.
După cum puteți vedea, este destul de ușor de înțeles și, prin urmare, de a construi.
Uită-te la imagine dacă vrei o idee despre ce componentă merge acolo. După cum probabil înțelegeți, nu este vorba despre o scară în nici un fel. Cablurile sunt mult mai lungi decât cele indicate în schema.
S-ar putea să fi observat, de asemenea, că emițătorul senzorului ultrasonic se află pe stick, iar receptorul este pe mâna stângă. Aceasta este partea dificilă pe care am menționat-o mai devreme: Trebuie să dezlănțuiți emițătorul ultrasonic de la unitatea senzor ultrasonic pentru ao separa de placa senzorilor.
Mai multe despre asta în pașii ulteriori. Acum hai să mergem la muncă!
Pasul 4: Construirea mănușii
Manusa contine un receptor ultra-sonic si patru butoane. Asta e!
Receptorul ultrasonic este amplasat în cutia neagră vizibilă pe unele dintre imaginile de mai jos.
Manusa are o suprafata mare, care este conectata la sol pe placa Arduino. Atunci când un deget este apăsat pe palmă, se creează o legătură între țesătura conductivă pe deget și palma.
Mai jos este imaginea a două modele diferite de mănuși. Unul are degetele detașabile, ceea ce permite ambilor jucători cu mâini foarte mici și foarte mari. Celălalt model este cusut direct pe o mănușă standard. Aș recomanda versiunea a doua, este mai ușor de construit și mai ușor de pus.
Pasul 5: Cod
Aici este codul Arduino necesar:
Partea de generare a sunetului în timp real este preluată din acest tutorial grozav.
------------------------------------------------------
// O matrice care conține forma de undă
// de sunet de chitară
formatul de undă
{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};
// Folosim această formă de undă pentru a schimba
// volumul producției
formatul de undăVolume
{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};
// O matrice folosită ca tampon pentru a evita
// distanța punctuală eronată
// măsurători
nesemnate int distance_buffer = {16000,
16000, 16000, 16000, 16000, 16000, 16000,
16000, 16000, 16000, 16000, 16000, 16000,
16000, 16000, 16000};
const int distanta_length = 3;
int distance_index = 0;
Valorile de depășire pentru 2 octave
int frecvențe = {39, 42, 44, 47,
50, 52, 56, 59, 63, 66, 70, 74, 79,
84, 89, 94, 100, 105, 112, 118, 126,
133, 141, 149};
// Pasul inițial
int pas = 160;
// Volum inițial și accelerare
// parametru
int lastAcc = 0;
volum flotant = 0;
// redare audio pe pinul 3
byte speakerpin = 3;
// variabila index pentru poziția în
// forma de undă
volatilă de octet de valută = 0
volatile octet currentvalue = 0;
// Pin folosit pentru senzorul ultrasonic
const int pingPin = 7;
// Pini pentru potențiometre
const int sustainPin = 1;
const int sensibilitatePin = 2;
/ / Pins pentru fiecare deget al stângii
// mână
const int finger1 = 9;
const int finger2 = 10;
const int finger3 = 11;
const int finger4 = 12;
int fingerValue = 0;
durată lungă, cm, cm;
void setup () {
pinMode (3, OUTPUT); // Speaker pe pinul 3
pinMode (finger1, INPUT);
pinMode (finger2, INPUT);
pinMode (finger3, INPUT);
pinMode (finger4, INPUT);
/**************************
Configurare audio PWM
****************************/
// setați Timer2 pentru a repeta modul PWM
// (se dublează frecvența PWM)
bitSet (TCCR2A, WGM21);
bitSet (TCCR2B, CS20);
bitClear (TCCR2B, CS21);
bitClear (TCCR2B, CS22);
// permite întreruperi acum că registrele
// au fost stabilite
sei ();
/*************************
Contorul de întrerupere a temporizatorului 1
*************************/
// dezactivează întreruperile în timp ce
// registrele sunt configurate
cli ();
/ * Funcționare normală a portului, deconectarea pinilor
de la funcționarea temporizatorului (pwm de rupere) * /
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);
/ * Modul 4, CTC cu TOP setat prin înregistrare
OCR1A. Ne permite să setăm calendarul variabil pentru
întrerupe prin scrierea de valori noi
OCR1A. * /
bitClear (TCCR1A, WGM10);
bitClear (TCCR1A, WGM11);
bitSet (TCCR1B, WGM12);
bitClear (TCCR1B, WGM13);
/ * setați prescalerul de ceas la / 8. * /
bitClear (TCCR1B, CS10);
bitSet (TCCR1B, CS11);
bitClear (TCCR1B, CS12);
/ * Dezactivează forța de ieșire Comparație pentru
Canalele A și B. * /
bitClear (TCCR1C, FOC1A);
bitClear (TCCR1C, FOC1B);
/ * Inițializează compararea rezultatelor
Înregistrați A la 160 pentru a seta
pasul inițial * /
OCR1A = 160;
// dezactivați întreruperea capturii de intrare
bitClear (TIMSK1, ICIE1);
// dezactiva ieșirea
// Comparați B Match Interrupt
bitClear (TIMSK1, OCIE1B);
// activați ieșirea
// Comparați o întrerupere a meciului
bitSet (TIMSK1, OCIE1A);
// dezactivați întreruperea fluxului
bitClear (TIMSK1, TOIE1);
// permite întreruperi acum că
// au fost stabilite registre
sei ();
}
// Dispozitiv de tratare a preaplinului cu temporizator
ISR (TIMER1_COMPA_vect) {
/ * timer1 ISR. De fiecare dată
este numit seta speakerpin la
următoarea valoare în forma de undă . Frecvență
Modularea se face prin schimbarea
calendarul dintre apelurile succesive ale
această funcție, de ex. pentru un ton de 1KHz,
setați calendarul astfel încât să ruleze
prin forma de undă de 1000 de ori
o secunda. * /
// reinițializați waveindex dacă a atins
// sfârșitul matricei
dacă (waveindex> 102) {
waveindex = 0;
}
// Setați valoarea de ieșire
dacă (volum> 0,03) {
analogWrite (speakerpin,
waveformVolume waveindex);
}
waveindex ++;
// Actualizați pitchul
OCR1A = pitch;
}
buclă voidă ()
{
// Dezactivați intrările, trimiteți un ping
// mesaj și așteptați răspunsul.
cli ();
pinMode (pingPin, OUTPUT);
digitalWrite (pingPin, LOW);
delayMicroseconds (2);
digitalWrite (pingPin, HIGH);
delayMicroseconds (5);
digitalWrite (pingPin, LOW);
durata = pulseIn (pingPin, HIGH, 2000);
sei ();
// convertiți ora la o distanță
// în centimetri
// și stocați în tampon
distance_buffer distance_index ++
% distance_length = durata / 20;
// Găsiți în tampon cel mai scurt
// distanța măsurată
cm = 16000;
pentru (int i = 0; i <distanta_ lungime; i ++) {
cm = min (cm, distanță_buffer i);
}
// Verificați ce degete sunt apăsate
fingerValue = 5;
if (! digitalRead (finger4)) {
fingerValue = 4;
}
if (! digitalRead (finger3)) {
fingerValue = 3;
}
if (! digitalRead (finger2)) {
fingerValue = 2;
}
if (! digitalRead (finger1)) {
fingerValue = 1;
}
// Actualizați suportul și
// valori de sensibilitate
suport plutitor =
hartă (analogRead (sustainPin), 0,
1024, 101, 130) / 100.0;
int sensibilitate =
Harta (analogRead (sensitivityPin),
0, 1024, 100, 200);
// Actualizați volumul
volum = volum / susținere;
dacă (volum <0) {
volum = 0;
}
// Verificați accelerometrul
int acc = analogRead (0);
int accDiff = ultimAcc - acc;
// Actualizați valoarea volumului
dacă (accDiff> 5 * (200 - sensibilitate)) {
volum + = (float)
pow (accDiff,
sensibilitate / 100,0) / 50000;
}
lastAcc = acc;
// Verificați dacă volumul nu este mai mare de 1
dacă (volum> .95) {
volum = .95;
}
// Actualizați volumul în forma de undă
pentru (int i = 0; i <= 102; i ++) {
undeformVolume i =
((formă de undă i - 127) * volum) + 127;
}
// Stabiliți pasul în funcție de distanță
// între cele două mâini și
// degetele presate
dacă (cm <102 && cm> 0) {
dacă (cm> 30) {
pitch = frecvențe 7 +
(((cm-30) / 24) * 4 + valoarea degetului-1);
} Else {
pitch = hartă (cm, 0, 30, 39, 79);
}
} Else {
pitch = frecvențe 7 +
(((102 - 30) / 24) * 4 + valoare deget - 1);
}
// Întârziere pentru a evita semnalizarea
întârziere (50);
}
------------------------------------------------------
