Die Idee dabei ist, eine tragbare virtuelle Gitarre zu bauen, die mit zwei Händen gesteuert werden kann, ähnlich wie beim Spielen von Air Guitar. Es wurde in einem zweiwöchigen Projekt bei erstellt und prototypisiert
Ziel ist es, das Gefühl zu bekommen, eine echte Gitarre zu spielen. Die AIRduino-Gitarre besteht aus einem Handschuh und einem Schläger.Der Handschuh wird verwendet, um den Ton einzustellen, und der Stock, um den Ton auszulösen.
Um einen solchen Trick auszuführen, verwendeten wir einen Beschleunigungsmesser und einen Ultraschallsensor (siehe Schritt 1 für eine Konzeptbeschreibung).
Schauen Sie sich die Video-Demo an, um eine genauere Vorstellung davon zu bekommen, wie es funktioniert, und machen Sie sich an die Arbeit, um Ihre eigenen zu bauen!
Das AIRduino-Team:
David Fournier, Jean-Louis Giordano, Monireh Sanaei, Maziar Shelbaf und Gustav Sohtell.
Zubehör:
Schritt 1: Konzeptbeschreibung
Die Air Guitar soll als Rechtshänder-Gitarre arbeiten.
Der Gitarren-Controller ist in zwei Teile unterteilt, den linken und den rechten Controller.
Mit dem linken Controller kann der Spieler seine Finger beugen und auf den Handschuh drücken, um die Tonhöhe zu ändern.
Der rechte Controller wird durch einen Stick dargestellt, der geschüttelt werden muss, um den Klang der Luftgitarre auszulösen.
Der Spieler kann auch den Abstand zwischen rechter und linker Hand ändern, um die Töne zu verändern und die verschiedenen Bünde am Gitarrenhals zu simulieren.
Um solche Tricks auszuführen, sind die Hauptkomponenten ein Beschleunigungsmesser zum "Fühlen" des Stickshakes, ein gehackter Ultraschallsensor zum Messen des Abstands zwischen der rechten Hand und dem Stick und leitfähiges Gewebe zum Herstellen des Handschuhs.
Alles in allem ist es ein ziemlich einfach zu bauendes Spielzeug. Der einzige schwierige Teil wäre der Ultraschall-Sensor-Hack, der etwas Fingerspitzengefühl erfordert. Sie benötigen einige grundlegende elektronische Kenntnisse, um die Anweisungen zu verstehen und um herauszufinden, was Sie falsch gemacht haben, als Sie etwas vermasselt haben und die Gitarre am Ende nicht funktioniert. Wir waren dort. :-)
Schritt 2: Einkaufsliste
Hier ist eine Liste von Dingen, die Sie benötigen, um Ihre eigene AIRduino-Gitarre zu bauen:
1. Drähte: leider viel für diese Prototypversion. Sie wurden verwendet, um die beiden Handschuhe und die Arduino-Teile miteinander zu verbinden. Fühlen Sie sich frei, diesen Teil des Designs zu verbessern, indem Sie es drahtlos machen!
2. Beschleunigungsmesser: Wird im Stab in der rechten Hand verwendet, um das Zittern zu erkennen. Wir haben einen dreiachsigen Beschleunigungsmesser verwendet, aber eine einzige Achse reicht aus
3. Ultraschallsensor: Zum Messen des Abstands zwischen beiden Händen des Players wurde Parallax # 28015 verwendet
4. Leitfähiges und dehnbares Gewebe: um den Handschuh zu bauen,
5. Arduino: Der Kern der Gitarre, der sich um alles kümmert. Ein Arduino Diecimila funktioniert gut.
6. Potentiometer: Zum Einstellen einiger Einstellungen ist ein Potentiometer mit einem Maximalwert von 1KOhm-1MOhm in Ordnung.
7. Schmelzkleber: ein bequemer Weg, um Dinge zusammenzuhalten,
8. 3,5-mm-Buchse: für den Audioausgang verwendet,
9. Klassisches elektronisches Zeug: Widerstände (10k), Kondensator (10uF), LEDs und eine Art Netzteil für das Arduino. (Eine 9V Batterie reicht völlig aus).
Schritt 3: Schaltpläne
Hier sind die elektronischen Schaltpläne für die AIRduino-Gitarre.
Wie Sie sehen, ist es ziemlich einfach zu verstehen und daher auch zu bauen.
Schauen Sie sich das Bild an, wenn Sie wissen möchten, welche Komponente wohin gehört. Wie Sie wahrscheinlich verstehen, ist dies in keiner Weise maßstabsgetreu. Die Kabel sind viel länger als im Schaltplan gezeigt.
Möglicherweise haben Sie auch bemerkt, dass sich der Sender des Ultraschallsensors auf dem Stick und der Empfänger auf der linken Seite befindet. Das ist der schwierige Teil, den ich bereits erwähnt habe: Sie müssen den Ultraschallsender von der Ultraschallsensoreinheit ablöten, um ihn von der Sensorplatine zu trennen.
Mehr dazu in späteren Schritten. Jetzt lass uns an die Arbeit gehen!
Schritt 4: Aufbau des Handschuhs
Der Handschuh enthält einen Ultraschallempfänger und vier Tasten. Das ist es!
Der Ultraschallempfänger befindet sich in der Blackbox, die auf einigen der folgenden Abbildungen zu sehen ist.
Der Handschuh hat eine große Fläche, die nur auf der Arduino-Platine mit Masse verbunden ist. Wenn ein Finger gegen die Handfläche gedrückt wird, wird eine Verbindung zwischen dem leitenden Stoff auf dem Finger und der Handfläche hergestellt.
Unten sehen Sie ein Bild von zwei verschiedenen Handschuhmodellen. Man hat abnehmbare Finger, wodurch beide Spieler mit sehr kleinen und sehr großen Händen spielen können. Das andere Modell wird direkt an einen Standardhandschuh angenäht. Ich würde die zweite Version empfehlen, sie ist einfacher zu erstellen und einfacher zu installieren.
Schritt 5: Code
Hier ist der Arduino-Code erforderlich:
Der Teil zur Echtzeit-Klangerzeugung stammt aus diesem großartigen Tutorial.
------------------------------------------------------
// Ein Array, das die Wellenform enthält
// eines Gitarrensounds
Zeichenwellenform =
{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};
// Wir verwenden diese Wellenform, um das zu ändern
// Lautstärke der Ausgabe
char waveVolume =
{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};
// Ein Array, das als zu vermeidender Puffer verwendet wird
// fehlerhafte pünktliche Entfernung
// Messungen
unsigned 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;
// Die Überlaufwerte für 2 Oktaven
int frequency = {39, 42, 44, 47,
50, 52, 56, 59, 63, 66, 70, 74, 79,
84, 89, 94, 100, 105, 112, 118, 126,
133, 141, 149};
// Anfangssteigung
int pitch = 160;
// Anfangsvolumen und Beschleunigung
// parameter
int lastAcc = 0;
Schwimmervolumen = 0;
// Audiowiedergabe an Pin 3
Byte Speakerpin = 3;
// Indexvariable für Position in
// Wellenform
flüchtiges Byte Wellenindex = 0
flüchtiger Bytestromwert = 0;
// Pin für Ultraschallsensor
const int pingPin = 7;
// Pins für die Potentiometer
const int sustainPin = 1;
const int sensitivityPin = 2;
// Stifte für jeden Finger von links
// Hand
const int finger1 = 9;
const int finger2 = 10;
const int finger3 = 11;
const int finger4 = 12;
int fingerValue = 0;
lange Dauer, Zoll, cm;
void setup () {
PinMode (3, OUTPUT); // Lautsprecher an Pin 3
pinMode (finger1, INPUT);
pinMode (finger2, INPUT);
pinMode (finger3, INPUT);
pinMode (finger4, INPUT);
/**************************
PWM-Audiokonfiguration
****************************/
// Timer2 auf schnellen PWM-Modus einstellen
// (verdoppelt die PWM-Frequenz)
bitSet (TCCR2A, WGM21);
bitSet (TCCR2B, CS20);
bitClear (TCCR2B, CS21);
bitClear (TCCR2B, CS22);
// Interrupts jetzt aktivieren, die registriert werden
// wurden gesetzt
sei ();
/*************************
Timer 1 Interrupt Konfiguration
*************************/
// Interrupts deaktivieren während
// Register sind konfiguriert
cli ();
/ * Normaler Portbetrieb, Pins nicht angeschlossen
aus dem Timer-Betrieb (Breaking PWM) * /
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);
/ * Modus 4, CTC, wobei TOP durch das Register eingestellt wird
OCR1A. Ermöglicht die Einstellung eines variablen Timings für
den Interrupt durch Schreiben neuer Werte auf
OCR1A. * /
bitClear (TCCR1A, WGM10);
bitClear (TCCR1A, WGM11);
bitSet (TCCR1B, WGM12);
bitClear (TCCR1B, WGM13);
/ * Stellen Sie den Clock Prescaler auf / 8. * /
bitClear (TCCR1B, CS10);
bitSet (TCCR1B, CS11);
bitClear (TCCR1B, CS12);
/ * Force Output Compare für deaktivieren
Kanäle A und B. * /
bitClear (TCCR1C, FOC1A);
bitClear (TCCR1C, FOC1B);
/ * Initialisiert Output Compare
Registrieren Sie A bei 160, um die
Anfangsabstand * /
OCR1A = 160;
// Eingangserfassungsinterrupt deaktivieren
bitClear (TIMSK1, ICIE1);
// Ausgabe deaktivieren
// Vergleiche B Match Interrupt
bitClear (TIMSK1, OCIE1B);
// Ausgabe aktivieren
// Vergleiche einen Match Interrupt
bitSet (TIMSK1, OCIE1A);
// Overflow Interrupt deaktivieren
bitClear (TIMSK1, TOIE1);
// aktiviere jetzt die Interrupts
// Register wurden gesetzt
sei ();
}
// Timer-Überlauf-Handler
ISR (TIMER1_COMPA_vect) {
/ * timer1 ISR. Jedes Mal wenn es
heißt es setzt den Speakerpin auf den
nächster Wert in der Wellenform . Frequenz
Die Modulation erfolgt durch Ändern der
Timing zwischen aufeinanderfolgenden Aufrufen von
Diese Funktion, z.B. für einen 1 kHz-Ton
Stellen Sie das Timing so ein, dass es läuft
1000-mal durch die Wellenform
eine Sekunde. * /
// setze den Wellenindex zurück, wenn er erreicht ist
// das Ende des Arrays
if (Wellenindex> 102) {
Wellenindex = 0;
}
// Ausgabewert setzen
if (Volumen> 0,03) {
analogWrite (Speakerpin,
WaveformVolume Waveindex);
}
waveindex ++;
// Aktualisiere die Tonhöhe
OCR1A = Tonhöhe;
}
leere Schleife ()
{
// Interputs deaktivieren, Ping senden
// message und warte auf die Antwort.
cli ();
pinMode (pingPin, OUTPUT);
digitalWrite (PingPin, LOW);
delayMicroseconds (2);
digitalWrite (pingPin, HIGH);
delayMicroseconds (5);
digitalWrite (PingPin, LOW);
duration = pulseIn (pingPin, HIGH, 2000);
sei ();
// Wandle die Zeit in eine Distanz um
// in Zentimetern
// und im Puffer speichern
distance_buffer distance_index ++
% distance_length = duration / 20;
// Suche im Puffer den kürzesten
// entfernung gemessen
cm = 16000;
für (int i = 0; i <distance_length; i ++) {
cm = min (cm, distance_buffer i);
}
// Überprüfen Sie, welche Finger gedrückt sind
fingerValue = 5;
if (! digitalRead (finger4)) {
fingerValue = 4;
}
if (! digitalRead (finger3)) {
fingerValue = 3;
}
if (! digitalRead (finger2)) {
fingerValue = 2;
}
if (! digitalRead (finger1)) {
fingerValue = 1;
}
// Aktualisiere das Sustain und
// empfindlichkeitswerte
float Sustain =
map (analogRead (sustainPin), 0,
1024, 101, 130) / 100.0;
Int Empfindlichkeit =
map (analogRead (sensitivityPin),
0, 1024, 100, 200);
// Aktualisiere das Volume
Lautstärke = Lautstärke / Sustain;
if (Volumen <0) {
Volumen = 0;
}
// Überprüfen Sie den Beschleunigungsmesser
int acc = analogRead (0);
int accDiff = lastAcc - acc;
// Aktualisiere den Volumenwert
if (accDiff> 5 * (200 - Empfindlichkeit)) {
volumen + = (float)
pow (accDiff,
Empfindlichkeit / 100,0) / 50000;
}
lastAcc = acc;
// Stellen Sie sicher, dass die Lautstärke nicht höher als 1 ist
if (volume> .95) {
Volumen = 0,95;
}
// Aktualisiere die Lautstärke in der Wellenform
für (int i = 0; i <= 102; i ++) {
WaveformVolume i =
((Wellenform i - 127) * Lautstärke) + 127;
}
// Stellen Sie die Tonhöhe entsprechend der Entfernung ein
// zwischen den beiden Händen und dem
// Finger gedrückt
if (cm <102 && cm> 0) {
if (cm> 30) {
Tonhöhe = Frequenzen 7 +
(((cm - 30) / 24) * 4 + fingerValue - 1);
}sonst{
Abstand = Karte (cm, 0, 30, 39, 79);
}
}sonst{
Tonhöhe = Frequenzen 7 +
(((102 - 30) / 24) * 4 + fingerValue - 1);
}
// Verzögerung, um Signalreflexionen zu vermeiden
Verzögerung (50);
}
------------------------------------------------------
