Hur man bygger en luftgitarr med Arduino, aka AIRduino gitarr (5 / 5 steg)

Steg 5: kod

Realtid ljud generation del tas från denna stora tutorial.

------------------------------------------------------
En array som innehåller vågformen
av en gitarr ljud
char vågform [] =
{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 använder denna vågform för att ändra den
volymen av produktionen
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};
En matris används som en buffert för att undvika
felaktiga punktliga avstånd
mätningar
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;

Overflow värdena för 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};

Första pitch
int pitch = 160;

Ursprunglig volym och acceleration
parametern
int lastAcc = 0;
flyta volym = 0;

ljuduppspelning på stift 3
byte speakerpin = 3;

index variabel för position i
vågform
flyktiga byte waveindex = 0
flyktiga byte currentvalue = 0;

PIN-kod används för ultra sonic sensor
CONST int pingPin = 7.

Stift för potentiometrar
CONST int sustainPin = 1;
CONST int sensitivityPin = 2;

Stift för varje finger vänstern
hand
CONST int finger1 = 9;
CONST int finger2 = 10;
CONST int finger3 = 11;
CONST int finger4 = 12;

int fingerValue = 0;

lång varaktighet, tum, cm;

void setup() {

pinMode(3,OUTPUT); Talare på stift 3

pinMode(finger1,INPUT);
pinMode(finger2,INPUT);
pinMode(finger3,INPUT);
pinMode(finger4,INPUT);

/**************************
PWM ljud konfiguration
****************************/
Ange Timer2 till fast PWM-läge
(dubbel PWM frekvens)
bitSet (TCCR2A, WGM21);
bitSet (TCCR2B, CS20);
bitClear (TCCR2B, CS21);
bitClear (TCCR2B, CS22);

Aktivera avbryter nu som registrerar
har ställts in
SEI();

/*************************
Timer 1-avbrott konfiguration
*************************/
Inaktivera avbrott medan
register är konfigurerade
CLI();

/ * Normal port drift, stiften kopplas från
från timer funktion (bryta pwm) * /
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);

/ * Läge 4, CTC med topp inställt av register
OCR1A. Ger oss möjlighet att ange variabel tidpunkten för
avbryta genom att skriva nya värden till
OCR1A. */
bitClear (TCCR1A, WGM10);
bitClear (TCCR1A, WGM11);
bitSet (TCCR1B, WGM12);
bitClear (TCCR1B, WGM13);

/ * klocka prescaler inställd på /8. */
bitClear (TCCR1B, CS10);
bitSet (TCCR1B, CS11);
bitClear (TCCR1B, CS12);

/ * Inaktivera kraft utdata jämför för
Kanalerna A och B. * /
bitClear (TCCR1C, FOC1A);
bitClear (TCCR1C, FOC1B);

/ * Initierar utdata jämför
Registrera dig A på 160 ställa den
första pitch * /
OCR1A = 160;

Inaktivera input capture avbrott
bitClear (TIMSK1, ICIE1);
avaktivera utgång
Jämföra B Match avbrott
bitClear (TIMSK1, OCIE1B);
Aktivera utgång
Jämföra en Match avbryta
bitSet (TIMSK1, OCIE1A);
Inaktivera Overflow avbryta
bitClear (TIMSK1, TOIE1);

Aktivera avbryter nu som
register har ställts in
SEI();
}

Timer overflow handler
ISR(TIMER1_COMPA_vect) {

/ * timer1 ISR. Varje gång det
kallas det anger speakerpin till de
nästa värde i vågform []. Frekvens
modulering är gjort genom att ändra den
timingen mellan på varandra följande samtal av
denna funktion, t.ex. för en 1KHz ton,
Ange tidsinställningar så att det körs
genom vågform [] 1000 gånger
en sekund. */

återställa waveindex om det har nått
i slutet av matrisen

om (waveindex > 102) {
waveindex = 0;
}

Ställa in produktionsvärde
om (volym > 0,03) {
analogWrite (speakerpin,
waveformVolume[waveindex]);
}
waveindex ++;

Uppdatera planen
OCR1A = stigningen.
}

void loop()
{
Desactivate interputs, skicka en ping
meddelande och vänta på svaret.
CLI();
pinMode (pingPin, produktionen);
digitalWrite (pingPin, låg);
delayMicroseconds(2);
digitalWrite (pingPin, hög);
delayMicroseconds(5);
digitalWrite (pingPin, låg);
längd = pulseIn (pingPin, hög, 2000);
SEI();
konvertera tiden till ett avstånd
i centimeter
och lagra i buffert
distance_buffer [distance_index ++
% distance_length] = varaktighet / 20;

Hitta i bufferten den kortaste
avståndet mätt
cm = 16000;
för (int jag = 0; jag < distance_length; i ++) {
cm = min (cm, distance_buffer[i]);
}

Kontrollera vilka fingrar trycker
fingerValue = 5;
IF(!digitalRead(finger4)) {
fingerValue = 4;
}
IF(!digitalRead(finger3)) {
fingerValue = 3;
}
IF(!digitalRead(finger2)) {
fingerValue = 2;
}
IF(!digitalRead(finger1)) {
fingerValue = 1;
}

Uppdatera sustain och
känslighet värden
float upprätthålla =
Map(analogRead(sustainPin), 0,
1024, 101, 130) / 100,0;
int känslighet =
Map(analogRead(sensitivityPin),
0, 1024, 100, 200);

Uppdatera volym
volym = volym / upprätthålla;
om (volym < 0) {
volym = 0;
}

Kontrollera accelerometern
int acc = analogRead(0);
int accDiff = lastAcc - acc;

Uppdatera volym värdet
om (accDiff > 5 * (200 - känslighet)) {
volym += (float)
pow (accDiff,
känslighet / 100,0) / 50000;
}
lastAcc = acc;

Kontrollera att volymen inte är högre än 1
om (volym > 95) {
volym =. 95;
}

Uppdatera volym i vågformen
för (int jag = 0; jag < = 102; i ++) {
waveformVolume [i] =
((vågform [i] - 127) * volym) + 127;
}

Inställning av tonhöjd utifrån avståndet
mellan två händer och den
fingrar tryckte
om (cm < 102 & & cm > 0) {
om (cm > 30) {
pitch = frekvenser [7 +
(((cm-30) / 24) * 4 + fingerValue - 1)];
} annat {
pitch = karta (cm, 0, 30, 39, 79);
}
} annat {
pitch = frekvenser [7 +
(((102-30)/24) * 4 + fingerValue - 1)];
}

Dröjsmål att undvika studsande signaler
Delay(50);
}

------------------------------------------------------