Paso 8: el Arduino sketch
Realmente quería un adivino que más personalidad que la máquina promedio, así que decidí que lo haría por lo que el usuario puede seleccionar el estado de ánimo del adivino. En el bosquejo, los archivos se dividen en diferentes secciones. Usted necesitará nombrar tus archivos de sonido después de los nombres de archivo enumeran en el sketch o cambie el nombre los nombres en el bosquejo después de sus archivos. Por ejemplo, las fortunas normales se nombran 1-14 (caso 1-14). Las fortunas sarcásticas se denominan 15s-29s (caso 15-29), así sucesivamente y así sucesivamente. Cuando se carga la tarjeta SD con los archivos de sonido, necesitará cambiar el nombre de tus archivos en consecuencia. Así que si usted se va a utilizar este bosquejo, para hacer una máquina de discos de Beatles, tendría que cambiar el nombre de Hey Jude "1" (que es 1, no 1.wav).Vas a necesitar el protector de la onda, el Arduino y una tarjeta SD. Usted también tendrá que instalar la biblioteca de WaveHC. Hay instrucciones en la Página Web de Adafruit sobre cómo convertir correctamente sus archivos de audio al formato adecuado para el protector de la onda. He utilizado Audacity para esto, ya que hay un montón de opciones para cambiar el sonido de los archivos de Audacity y también porque realmente no quería que el adivino al sonido como yo.
Hay sólo unos pocos pins digitales disponibles porque el protector de la onda necesita algunos de los pasadores para comunicarse con Arduino. En mi bosquejo, usé pernos 6,7,8 y 9, así como pin analógico 5. El dibujo utiliza el ruido del pin analógico 0 para una selección más aleatoria de audio. Mi proyecto utiliza dos diferentes fuentes de luz. En el bosquejo, son leduvPin y ledstrobePin. También utiliza un pin para control del motor (pin 9) y un pin para la ranura de moneda (pin 8), botón rotulado en el bosquejo. El bote está conectado al pin analógico 5.
#include < FatReader.h >
#include < SdReader.h >
#include < avr/pgmspace.h >
#include "WaveUtil.h"
#include "WaveHC.h"
int ledstrobePin = 7;
int leduvPin = 6;
int delayPeriod = 20;
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 sistema de archivos en la tarjeta
FatReader f; Esto contiene la información del archivo estamos jugamos
Ola WaveHC; Este es el único objeto (audio) de la onda, puesto que sólo jugaremos uno a la vez
#define MOTOR 9
#define tecla 8
#define LED 13
int val = 0;
int potvalue = 0;
randNum largo;
Esta práctica función devolverá el número de bytes actualmente libres en RAM, ideal para depuración!
int freeRam(void)
{
extern int __bss_end;
extern int * __brkval;
int free_memory;
Si ((int) __brkval == 0) {}
free_memory = ((int) & free_memory)-((int) & __bss_end);
}
Else {}
free_memory = ((int) & free_memory)-((int) __brkval);
}
volver free_memory;
}
void sdErrorCheck(void)
{
Si (! card.errorCode()) retorno;
putstring ("\n\rSD I/O error:");
Serial.Print(Card.ErrorCode(), hexagonal);
putstring (",");
Serial.println(Card.errorData(), hexagonal);
while(1);
}
void setup() {}
Configurar puerto serie
Serial.Begin(9600);
pinMode (botón, entrada);
pinMode (LED, salida);
pinMode (leduvPin, salida);
pinMode (ledstrobePin, salida);
randomSeed(analogRead(0));
digitalWrite (botón, alto);
pinMode (MOTOR, salida);
putstring ("memoria RAM libre:"); Esto puede ayudar con la depuración, es malo quedarse sin RAM
Serial.println(freeRam()); Si es menor de 150 bytes escribe con problemas!
Configurar los pines de salida para el control de la DAC. Este los pernos se definen en la biblioteca
pinMode (2, salida);
pinMode (3, salida);
pinMode (4, salida);
pinMode (5, salida);
Si (! card.init(true)) {//play con spi de 4 MHz si 8MHz no funciona para usted
Si (! card.init()) {//play con spi de 8 MHz (por defecto más rápido!)
putstring_nl ("tarjeta init. no se pudo!"); Algo salió mal, permite imprimir por qué
sdErrorCheck();
while(1); entonces 'detener': ¡ no!
}
permiten optimizar la lectura - algunas tarjetas pueden tiempo de espera. Desactivar si tienes problemas
card.partialBlockRead(true);
Ahora buscaremos una partición FAT!
parte de uint8_t;
para (parte = 0; parte < 5; parte ++) {/ / tenemos hasta 5 ranuras en
Si (vol.init (tarjeta, parte))
rotura; encontró uno, permite la libertad bajo fianza
}
Si (parte == 5) {/ / si terminamos por no encontrar uno :(
putstring_nl ("No válida partición FAT!");
sdErrorCheck(); Algo salió mal, permite imprimir por qué
while(1); entonces 'detener': ¡ no!
}
Permite decir que el usuario lo que encontramos
putstring ("partición de uso");
Serial.Print (parte, DEC);
putstring (", el tipo es grasa");
Serial.println(Vol.fatType(),DEC); ¿FAT16 o FAT32?
Intente abrir el directorio raíz
Si (! {root.openRoot(vol))}
putstring_nl ("no se puede abrir raíz dir!"); Algo salió mal,
while(1); entonces 'detener': ¡ no!
}
¡ UF! Llegamos pasado las partes difíciles.
putstring_nl("Ready!");
/ * TCCR2A = 0;
TCCR2B = 1 << CS22 | 1 << CS21 | 1 << CS20;
Permiten interrumpir el desbordamiento del TIMER2
TIMSK2 | = 1 << TOIE2;
*/
}
void loop()
{
Val = digitalRead(BUTTON);
potvalue = analogRead(5);
Serial.println (potvalue, DEC);
Si (val == alto & & potvalue > = 0 & & potvalue < = 4)
{
randNum = al azar (1, 14);
Delay(1000);
interruptor (randNum)
{
caso 1:
Serial.println(1);
playcomplete("1.wav");
rotura;
caso 2:
Serial.println(2);
playcomplete("2.wav");
rotura;
caso 3:
Serial.println(3);
playcomplete("3.wav");
rotura;
caso 4:
Serial.println(4);
playcomplete("4.wav");
rotura;
caso 5:
Serial.println(5);
playcomplete("5.wav");
rotura;
caso 6:
Serial.println(6);
playcomplete("6.wav");
rotura;
caso 7:
Serial.println(7);
playcomplete("7.wav");
rotura;
caso 8:
Serial.println(8);
playcomplete("8.wav");
rotura;
caso 9:
Serial.println(9);
playcomplete("9.wav");
rotura;
caso 10:
Serial.println(10);
playcomplete("10.wav");
rotura;
caso 11:
Serial.println(11);
playcomplete("11.wav");
rotura;
caso 12:
Serial.println(12);
playcomplete("12.wav");
rotura;
caso 13:
Serial.println(13);
playcomplete("13.wav");
rotura;
caso 14:
Serial.println(14);
playcomplete("14.wav");
rotura;
por defecto:
rotura;
}
}
Si (val == alto & & potvalue > = 5 & & potvalue < = 15)
{
randNum = random (15, 29);
Delay(1000);
interruptor (randNum)
{
caso 15:
Serial.println(15);
playcomplete "(15s. WAV");
rotura;
caso 16:
Serial.println(16);
playcomplete "(16s. WAV");
rotura;
caso 17:
Serial.println(17);
playcomplete "(17s. WAV");
rotura;
caso 18:
Serial.println(18);
playcomplete ("de 18 años. WAV");
rotura;
caso 19:
Serial.println(19);
playcomplete («19s. WAV");
rotura;
caso 20:
Serial.println(20);
playcomplete "(20s. WAV");
rotura;
caso 21:
Serial.println(21);
playcomplete ("21s. WAV");
rotura;
caso 22:
Serial.println(22);
playcomplete "(22s. WAV");
rotura;
caso 23:
Serial.println(23);
playcomplete "(23s. WAV");
rotura;
caso 24:
Serial.println(24);
playcomplete ("24s. WAV");
rotura;
caso 25:
Serial.println(25);
playcomplete ("de 25 años. WAV");
rotura;
caso 26:
Serial.println(26);
playcomplete "(26s. WAV");
rotura;
caso 27:
Serial.println(27);
playcomplete "(27s. WAV");
rotura;
caso 28:
Serial.println(28);
playcomplete ("28s. WAV");
rotura;
caso 29:
Serial.println(29);
playcomplete ("29s. WAV");
rotura;
por defecto:
rotura;
}
}
Si (val == alto & & potvalue > = 16 & & potvalue < = 22)
{
randNum = random (30, 44);
Delay(1000);
interruptor (randNum)
{
caso 30:
Serial.println(30);
playcomplete ("30m. WAV");
rotura;
caso 31:
Serial.println(31);
playcomplete ("31m. WAV");
rotura;
caso 32:
Serial.println(32);
playcomplete ("32m. WAV");
rotura;
caso 33:
Serial.println(33);
playcomplete ("33m. WAV");
rotura;
caso 34:
Serial.println(34);
playcomplete ("34m. WAV");
rotura;
caso 35:
Serial.println(35);
playcomplete ("35m. WAV");
rotura;
caso 36:
Serial.println(36);
playcomplete ("36m. WAV");
rotura;
caso 37:
Serial.println(37);
playcomplete ("37m. WAV");
rotura;
caso 38:
Serial.println(38);
playcomplete ("38m. WAV");
rotura;
caso 39:
Serial.println(39);
playcomplete ("39m. WAV");
rotura;
caso 40:
Serial.println(40);
playcomplete ("40m. WAV");
rotura;
caso 41:
Serial.println(41);
playcomplete ("41m. WAV");
rotura;
caso 42:
Serial.println(42);
playcomplete ("42m. WAV");
rotura;
caso 43:
Serial.println(43);
playcomplete ("43m. WAV");
rotura;
caso 44:
Serial.println(44);
playcomplete ("44m. WAV");
rotura;
por defecto:
rotura;
}
}
Si (val == alto & & potvalue > = 23 & & potvalue < = 1023)
{
randNum = random (45, 60);
Delay(1000);
interruptor (randNum)
{
caso 45:
Serial.println(45);
playcomplete("45.wav");
rotura;
caso 46:
Serial.println(46);
playcomplete («46e. WAV");
rotura;
caso 47:
Serial.println(47);
playcomplete ("47e. WAV");
rotura;
caso 48:
Serial.println(48);
playcomplete ("48e. WAV");
rotura;
caso 49:
Serial.println(49);
playcomplete "(49e. WAV");
rotura;
caso 50:
Serial.println(50);
playcomplete ("50e. WAV");
rotura;
caso 51:
Serial.println(51);
playcomplete ("51e. WAV");
rotura;
caso 52:
Serial.println(52);
playcomplete ("52e. WAV");
rotura;
caso 53:
Serial.println(53);
playcomplete ("53e. WAV");
rotura;
caso 54:
Serial.println(54);
playcomplete "(54e. WAV");
rotura;
caso 55:
Serial.println(55);
playcomplete ("55e. WAV");
rotura;
caso 56:
Serial.println(56);
playcomplete "(56e. WAV");
rotura;
caso 57:
Serial.println(57);
playcomplete ("57e. WAV");
rotura;
caso 58:
Serial.println(58);
playcomplete ("58e. WAV");
rotura;
caso 59:
Serial.println(59);
playcomplete ("59e. WAV");
rotura;
caso 60:
Serial.println(60);
playcomplete ("60e. WAV");
rotura;
por defecto:
rotura;
}
}
}
Reproduce un archivo completo de principio a fin sin pausa.
void playcomplete(char *name) {}
llamar a nuestro ayudante para buscar y reproducir este nombre
playfile(Name);
mientras (wave.isplaying) {}
digitalWrite (MOTOR, alto);
Flash (20, delayPeriod);
digitalWrite (MOTOR, baja);
no hacer nada durante la reproducción de su
}
su hecho reproduciendo
}
anular el flash (int numFlashes, int d)
{
para (int i = 0; i < numFlashes; i ++)
{
digitalWrite (ledstrobePin, HIGH);
digitalWrite (leduvPin, bajo);
demora (d);
digitalWrite (ledstrobePin, bajo);
digitalWrite (leduvPin, HIGH);
demora (d);
digitalWrite (ledstrobePin, bajo);
digitalWrite (leduvPin, bajo);
}
}
void playfile(char *name) {}
ver si el objeto ola está haciendo algo
Si (wave.isplaying) {}
Flash (20, delayPeriod) ;// ya jugando algo, así que detenerlo!
Wave.STOP(); Basta
}
Buscar en el directorio raíz y abre el archivo
Si (! f.open (raíz, nombre)) {}
putstring ("no puede abrir archivo"); Serial.Print(Name); retorno;
}
Leer bien el archivo y convertirlo en un objeto de onda
Si (! {wave.create(f))}
putstring_nl ("no un válido WAV"); retorno;
}
OK el tiempo para jugar! iniciar la reproducción
Wave.Play();
}
