Equipo de Rebecca (6 / 7 paso)

Paso 6: Código de Arduino

/ * no olvide descargar la biblioteca de WaveHC, disponible aquí:
* http://www.ladyada.net/make/waveshield/download.html
*
* código modificado de http://www.ladyada.net/media/wavshield/SampleRateMod.pde
*
* La orientación del acelerómetro es importante para que este código funcione correctamente. El
* acelerómetro debe ser aproximadamente paralela a la Arduino, con el control de volumen en la parte superior como la
* el dispositivo se apoya en su cadera.
*/

#include < WaveHC.h >
#include < WaveUtil.h >

Tarjeta SdReader; Este objeto contiene la información de la tarjeta
FatVolume vol; Contiene la información de la partición en la tarjeta
FatReader raíz; Esto contiene la información para el directorio de raíz de volúmenes
Archivo FatReader; Este objeto representa el archivo WAV
Ola WaveHC; Este es el único objeto (audio) de la onda, puesto que sólo jugaremos uno a la vez

/*
* Definir macro para mensajes de error en memoria flash
*/
#define error(msg) error_P(PSTR(msg))

Cosas de LED
largo intervalo de tiempo = 1000;
int ledPin = 7; el número de los pines del LED

int ledState = bajo; ledState permite configurar el LED
previousMillis largo = 0; almacenará la última vez actualizó a LED

//////////////////////////////////// SETUP
void setup() {}
pinMode (ledPin, salida);
Serial.Begin(9600);
Serial.println ("onda prueba!");

trate de card.init(true) si se producen errores en el protector de la onda V1.0
Si (! {card.init())}
error ("tarjeta init. no se pudo!");
}
permiten optimizar la lectura - algunas tarjetas pueden tiempo de espera
card.partialBlockRead(true);

Si (! {vol.init(card))}
error ("no hay partición!");
}
Si (! {root.openRoot(vol))}
error ("no pudo abrir raíz");
}
putstring_nl ("archivos encontrados:");
root.LS();
}

declarition hacia adelante
void playcomplete (FatReader & archivo);

//////////////////////////////////// LOOP
void loop() {}
uint8_t i, r;
nombre c, Char [15];
dir_t dir;

root.Rewind();
desplazarse por los archivos en el directorio
mientras (root.readDir(dir) > 0) {}
sólo juego. Archivos WAV
Si (! strncmp_P ((char *) & dir.name[8]. Continuar PSTR("WAV")));

Si (! file.open (vol, dir)) {}
putstring ("no se puede abrir");
printEntryName(dir);
continuar;
}
putstring ("\n\rPlaying");
printEntryName(dir);
Serial.println();
playcomplete(File);
File.Close();
}
}

/////////////////////////////////// HELPERS
/*
* imprimir mensaje de error y detener la
*/
void error_P (const char * str)
{
PgmPrint ("Error:");
SerialPrint_P(str);
sdErrorCheck();
while(1);
}
/*
* imprimir mensaje de error y detener si error E/S SD, ideal para depuración!
*/
void sdErrorCheck(void)
{
Si (! card.errorCode()) retorno;
PgmPrint ("\r\nSD I/O error:");
Serial.Print(Card.ErrorCode(), hexagonal);
PgmPrint (",");
Serial.println(Card.errorData(), hexagonal);
while(1);
}
int16_t lastpotval = 0;
#define histéresis 3
/*
* reproducir el archivo con los cambios de velocidad de muestra
*/

void makeLEDsblink() {}
unsigned currentMillis largo = millis();
putstring ("currentMillis ="); Serial.println(currentMillis);
putstring ("prevMillis ="); Serial.println(previousMillis);
putstring ("intervalo ="); Serial.println(Interval);
Si (currentMillis - previousMillis > intervalo) {}
guardar la última vez que titilaba el LED
previousMillis = currentMillis;

Si el LED está apagado gire sobre y viceversa:
Si (ledState == LOW) {}
ledState = alto; }
Else {}
ledState = bajo;
}

Set el LED con la ledState de la variable:
digitalWrite (ledPin, ledState);
}
}

void playcomplete (FatReader & archivo) {}
int16_t potval = 450;
newsamplerate de uint32_t;
counter1 int = 0;
counter2 int = 0;
int accelValue;

Si (! {wave.create(file))}
putstring_nl ("no un válido WAV"); retorno;
}
OK el tiempo para jugar!
Wave.Play();

mientras (wave.isplaying) {}
makeLEDsblink();
accelValue = analogRead(0);
Serial.println(accelValue);
Si {} (accelValue < 350)
counter2 ++;
}
Si {} (counter1 > 30)
Serial.println(counter2);
potval = (counter2 * 18) + 450;
counter1 = 0;
counter2 = 0;
}
Si (((potval-lastpotval) > histéresis) || ((lastpotval-potval) > histéresis)) {
putstring ("pote ="); Serial.println (potval, DEC);
putstring ("tickspersam ="); Serial.Print (wave.dwSamplesPerSec, DEC); putstring ("->");
newsamplerate = wave.dwSamplesPerSec;
newsamplerate * = potval;
newsamplerate = 512; queremos 'split' entre acelerado y frenado.
Si {} (newsamplerate > 48000)
newsamplerate = 48000;
}
Si (newsamplerate < 1000) {}
newsamplerate = 1000;
}
wave.setSampleRate(newsamplerate);
intervalo = 7500000/newsamplerate;
putstring ("intervalo ="); Serial.println (potval, DEC); Serial.println(Interval);
Serial.println (newsamplerate, DEC);
lastpotval = potval;
}
Delay(100);
counter1 ++;
}
sdErrorCheck();
}