Guantes de Arduino (un intento) (2 / 5 paso)

Paso 2: El esquema / el código

Este es el esquema y el código que utilicé desde el instructable. La única diferencia que hice era que quería utilizar dos guantes en vez de un guante y palo. De esta manera si quisieras mime cualquier otro instrumento que podría, por ejemplo si quería jugar como un arpa o algo. Esa decisión fue puramente basada en visual.

------------------------------------------------------
Una matriz que contiene la forma de onda
de un sonido de guitarra
Char [] de la forma de onda =
{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};

Utilizamos esta forma de onda para cambiar el
volumen de la salida
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};
Una matriz que se utiliza como un buffer para evitar
distancia puntual errónea
mediciones de
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;

Los valores de desbordamiento de 2 octavas
int frecuencia [] = {39, 42, 44, 47,
50, 52, 56, 59, 63, 66, 70, 74, 79,
84, 89, 94, 100, 105, 112, 118, 126,
133, 141, 149};

Tono inicial
campo de int = 160;

Aceleración y volumen inicial
parámetro
int lastAcc = 0;
volumen del flotador = 0;

reproducción de audio en el pin 3
byte speakerpin = 3;

variable índice para la posición en
forma de onda
volátiles byte waveindex = 0
currentvalue volátiles byte = 0;

Perno usado para sensor ultrasónico
const int pingPin = 7;

Pins para los potenciómetros
const int sustainPin = 1;
const int sensitivityPin = 2;

Clavijas para cada dedo de la izquierda
mano
const int finger1 = 9;
const int finger2 = 10;
const int finger3 = 11;
const int finger4 = 12;

int fingerValue = 0;

larga duración, pulgadas, cm;

void setup() {}

pinMode(3,OUTPUT); Altavoz en el pin 3

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

/**************************
Configuración de audio PWM
****************************/
Timer2 Set rápido modo PWM
(duplica la frecuencia PWM)
bitSet (TCCR2A, WGM21);
bitSet (TCCR2B, CS20);
bitClear (TCCR2B, CS21);
bitClear (TCCR2B, CS22);

habilitar interrupciones ahora registra
se han establecido
SEI();

/*************************
Configuración de interrupción de TIMER 1
*************************/
deshabilitar interrupciones mientras
se configuran los registros
CLI();

/ * Operación normal del puerto, pernos desconectados
de funcionamiento del temporizador (rompiendo pwm) * /
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);
bitClear (TCCR1A, COM1A1);

/ * 4, CTC con tapa set por registro
OCR1A. Nos permite establecer sincronización variable para
la interrupción al escribir nuevos valores a
OCR1A. */
bitClear (TCCR1A, WGM10);
bitClear (TCCR1A, WGM11);
bitSet (TCCR1B, WGM12);
bitClear (TCCR1B, WGM13);

/ * establece el prescaler de reloj en 8.  */
bitClear (TCCR1B, CS10);
bitSet (TCCR1B, CS11);
bitClear (TCCR1B, CS12);

/ * Deshabilitar fuerza salida compara para
Canales A y B. * /
bitClear (TCCR1C, FOC1A);
bitClear (TCCR1C, FOC1B);

/ * Inicializa salida compara
Registro A 160 para establecer la
inicial de campo * /
OCR1A = 160;

desactivar la interrupción de la captura de entrada
bitClear (TIMSK1, ICIE1);
desactivar salida
Comparar interrupción de partido B
bitClear (TIMSK1, OCIE1B);
activar salida
Comparar una interrupción del partido
bitSet (TIMSK1, OCIE1A);
desactivar el desbordamiento de interrumpir
bitClear (TIMSK1, TOIE1);

Enable interrumpe ahora
se han establecido registros
SEI();
}

Controlador de desbordamiento del temporizador
{ISR(TIMER1_COMPA_vect)}

/ * ISR timer1  Cada vez
se llama fija speakerpin a la
siguiente valor en forma de onda []. Frecuencia
modulación se hace cambiando la
tiempo entre llamadas sucesivas de
Esta función, por ejemplo, para un tono de 1KHz,
configurar la sincronización para que se ejecute
a través de la forma de onda [] 1000 veces
un segundo. */

restablecer waveindex si ha alcanzado
el final de la matriz

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

Establecer el valor de salida
Si {} (volumen > 0.03)
analogWrite (speakerpin,
waveformVolume[waveindex]);
}
waveindex ++;

Actualización de la echada
OCR1A = pitch;
}

void loop()
{
Desactivar interputs, enviar un ping
mensaje y espere la respuesta.
CLI();
pinMode (pingPin, salida);
digitalWrite (pingPin, LOW);
delayMicroseconds(2);
digitalWrite (pingPin, HIGH);
delayMicroseconds(5);
digitalWrite (pingPin, LOW);
duración = pulseIn (pingPin, HIGH, 2000);
SEI();
convertir el tiempo en una distancia
en centímetros
y almacenar en búfer
distance_buffer [distance_index ++
distance_length %] = Duración / 20;

Encuentra en el búfer de la menor
distancia medida
cm = 16000;
para (int i = 0; i < distance_length; i ++) {}
cm = min (cm, distance_buffer[i]);
}

Comprobar que los dedos se presionan
fingerValue = 5;
{if(!digitalRead(finger4))}
fingerValue = 4;
}
{if(!digitalRead(finger3))}
fingerValue = 3;
}
{if(!digitalRead(finger2))}
fingerValue = 2;
}
{if(!digitalRead(finger1))}
fingerValue = 1;
}

Actualizar el tiempo de sostenimiento y
valores de sensibilidad
mantener la flotación =
Map(analogRead(sustainPin), 0,
1024, 101, 130) / 100.0;
sensibilidad de int =
Map(analogRead(sensitivityPin),
0, 1024, 100, 200);

Actualizar el volumen
volumen = volumen / sostener;
Si (volumen < 0) {}
volumen = 0;
}

Compruebe el acelerómetro
acc de int = analogRead(0);
int accDiff = lastAcc - CAC;

Actualizar el valor de volumen
Si (accDiff > 5 * (200 - sensibilidad)) {}
volumen += (flotador)
Pow (accDiff,
sensibilidad / 100.0) / 50000;
}
lastAcc = acc;

Compruebe que el volumen no es mayor que 1
Si {} (volumen > 95)
volumen =. 95;
}

Actualización del volumen en la forma de onda
para (int i = 0; i < = 102; i ++) {}
waveformVolume [i] =
((forma de onda [i] - 127) * volumen) + 127;
}

Establecer el tono según la distancia
entre las dos manos y la
dedos presionando
Si (cm < 102 & & cm > 0) {}
Si (cm > 30) {}
Pitch = frecuencias [7 +
(((cm-30) / 24) * 4 + fingerValue - 1)];
} else {}
Pitch = mapa (cm, 0, 30, 39, 79);
}
} else {}
Pitch = frecuencias [7 +
(((102-30)/24) * 4 + fingerValue - 1)];
}

Retardo para evitar rebotes de señales
Delay(50);
}

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