IMP-ERSONATOR: Electric Imp + Arduino + protector de la onda = reproductor de archivos de sonido remoto (3 / 7 paso)

Paso 3: Añadir el código para el Arduino

Lo primero es establecer una conexión en serie con el Imp eléctrico para que las señales recibidas pueden ser utilizadas.
Entonces el código trata una señal recibida en uno de los pasadores del Imp como si fuera un pulsador. Esto a su vez hace que un archivo de sonido a reproducir desde la SD a través de la biblioteca de protector de la onda.

Copie el código abajo y pegarlo en el IDE de Arduino y subirlo a la Junta:

/*
Este código establece una conexión serial a un archivos de sonido eléctrico Imp y disparadores para reproducir desde una tarjeta SD cuando se recibe una señal de la Imp.
Básicamente es un mashup de lo ejemplo de botones escudo de onda y el ejemplo de arduino básico eléctrico imp
Pernos:
8,9 para imp
Pines 13, 12 y 11 se utilizan para hablar de la tarjeta SD y no se puede cambiar.
El resto de los pines, sin embargo, son más flexibles.
2 -> LCS
3 -> CLK
4 -> DI
5 -> LAT
10 -> CCS
0 = onwayhome.wav
6 = friday.wav
7 = tea.wav
*/

Necesita la biblioteca de WaveHC
#include < FatReader.h >
#include < SdReader.h >
#include < avr/pgmspace.h >
#include "WaveUtil.h"
#include "WaveHC.h"
#include < SoftwareSerial.h >
configurar un conncetion serial para el Imp
ImpSerial SoftwareSerial (8, 9); RX 8, TX 9

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 DEBOUNCE 5 / botón debouncer

Aquí es donde definimos los "botones" que vamos a utilizar - en este caso están conectados a los pines en el Imp eléctrico
botones de Byte [] = {6,0,7};
Esta macro útil nos permite determinar cuán grande es la matriz hasta arriba, comprobando el tamaño
#define NUMBUTTONS sizeof(buttons)
haremos el seguimiento si un botón se presiona sólo, sólo lanzado o 'presionado' (estado actual)
byte volátil presiona [NUMBUTTONS], justpressed [NUMBUTTONS], justreleased [NUMBUTTONS];

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() {}
byte me;

Configurar puerto serie
Serial.Begin(19200);
putstring_nl ("WaveHC con");
Serial.Print (NUMBUTTONS, DEC);
putstring_nl("buttons");

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);
establecer la tarifa de datos para el puerto SoftwareSerial
impSerial.begin(19200);

Hacer entrada y habilitar las resistencias pull-up en las patillas del interruptor
para (i = 0; i < NUMBUTTONS; i ++) {}
pinMode (botones [i], entrada);
digitalWrite (botones [i], HIGH);
}

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;

}

{Signal(TIMER2_OVF_vect)}
check_switches();
}

void check_switches()
{
Static byte previousstate [NUMBUTTONS];
currentstate static byte [NUMBUTTONS];
Índice de bytes;

para (índice = 0; índice < NUMBUTTONS; índice ++) {}
CurrentState [índice] = digitalRead(buttons[index]);   leer el botón

/*
Serial.Print (índice, DEC);
Serial.Print (": cstate =");
Serial.Print (currentstate [índice], DEC);
Serial.Print (", pstate =");
Serial.Print (previousstate [index], DEC);
Serial.Print (", presione =");
*/

Si (currentstate [índice] == {} previousstate[index])
Si ((presiona [índice] == LOW) & & (currentstate [índice] == LOW)) {}
solo presiona
justpressed [index] = 1;
}
else if ((presiona [índice] == HIGH) & & (currentstate [índice] == HIGH)) {}
acaba de publicar
justreleased [index] = 1;
}
presiona [índice] =! currentstate [índice];  Recuerde, medios digitales de alta no
}
Serial.println (prensada [índice], DEC);
previousstate [index] = currentstate [índice];   mantener una cuenta corriente de los botones
}
}

void loop() {}
Enviar datos desde el software de serie
Si (impSerial.available())
Serial.Write(impSerial.Read());  para el hardware de serie
Enviar datos desde el hardware serie
Si (Serial.available())
impSerial.write(Serial.read());  el software serie

byte me;

Si (justpressed[0]) {}
justpressed [0] = 0;
Serial.println ("pin 6 activadas");
playcomplete("Home.wav");
}

Si (justpressed[1]) {}
justpressed [1] = 0;
Serial.println ("pin 0 activadas");
playcomplete("Friday.wav");
}
Si (justpressed[2]) {}
justpressed [2] = 0;
Serial.println ("pin 7 activadas");
playcomplete("Tea.wav");
}
/*
Si (justpressed[3]) {}
justpressed [3] = 0;
playcomplete ("su Song.wav");
}
Si (justpressed[4]) {}
justpressed [4] = 0;
playcomplete ("su Song.wav");
}
Si (justpressed[5]) {}
justpressed [5] = 0;
playcomplete ("su Song.wav");
}
*/
}

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) {}
no hacer nada durante la reproducción de su
}
su hecho reproduciendo
}

void playfile(char *name) {}
ver si el objeto ola está haciendo algo
Si (wave.isplaying) {/ / así que ya está reproduciendo algo, stop!
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();
}