Luces de Navidad de Arduino (14 / 14 paso)

Paso 14: Software

Diré que obtuve mi comienzo de este tiempo de alguna otra página. No puedo encontrar donde lo conseguí, y tuvo que hacer muchos cambios de todos modos, así que yo soy carga aquí. Una vez que tengas esto es muy fácil de crear un programa para cualquier canción... pero si eres como yo es mejor en el cableado técnico y programación que están emparejando los baile luces música... para tener un punto de partida es una gran ayuda.

Así que aquí está el código. Otra vez es el código para la alegría en el archivo del mundo. La versión que subí es MP3, pero si se utiliza el protector de la onda tendrá que convertir a WAV.

También, me cansé de lidiar con el código muy largo para las luces en el lazo, así que hice una función, llamada "joy()".
Aquí está el código de Arduino:

Por: Tre' Landrum
#include
#include
#include
#include "WaveUtil.h"
#include "WaveHC.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 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

Esto es para la alegría de durante las luces bailar al mundo
Si usas el Uno en lugar de la Mega, necesitará cambiar estos pines. Si utilizas el WaveShield sólo tienes unos pocos pins avaialbe... 6 a 9 de la parte superior de mi cabeza.
light1 int = 22;
light2 int = 24;
light3 int = 26;
light4 de int = 28;
int light5 = 30;
int light6 = 32;
int light7 = 34;
int light8 = 36;
int s = 150;
int ds = 225;
int e = 300;
de int = 450;
int q = 600; 600
int dq = 900;
int h = 0; 1200
int dh = 1800;
int comienzo;
int fin;
int tiempo;
int

Va a cambiar las variables:

Aquí es donde definimos los botones que vamos a utilizar. botón "1" es la primera, botón "6" es el 6, etc.
botones de Byte [] = {14, 15, 16, 17, 18, 19};
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' (el 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(9600);
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);

pin13 LED
pinMode (13, salida);

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 <
Permiten interrumpir el desbordamiento del TIMER2
TIMSK2 | = 1 <
pinMode (light1, salida);
pinMode (light2, salida);
pinMode (light3, salida);
pinMode (light4, salida);
pinMode (light5, salida);
pinMode (light6, salida);
pinMode (light7, salida);
pinMode (light8, salida);

el relé de SainSmart son de alta
digitalWrite(light1,HIGH);
digitalWrite(light2,HIGH);
digitalWrite(light3,HIGH);
digitalWrite(light4,HIGH);
digitalWrite(light5,HIGH);
digitalWrite(light6,HIGH);
digitalWrite(light7,HIGH);
digitalWrite(light8,HIGH);
Serial.Begin(9600);

} //void setup()

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

Asegúrese de que cambiar el nombre del archivo que usted desee
playfile ("alegría. WAV");

Joy(); Esta es la función que desempeña la alegría al mundo

} //void loop() {}

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

Función para hacer los diferentes filamentos de luz diferentes
void joy() {}

putstring_nl ("comienzo de la alegría al mundo");

Start = millis();
digitalWrite (light1, LOW);
digitalWrite (light8, bajo);
Delay(q);
digitalWrite (light1, HIGH);
digitalWrite (light8, HIGH);

digitalWrite (light2, LOW);
digitalWrite (light7, bajo);
Delay(de);
digitalWrite (light2, HIGH);
digitalWrite (light7, HIGH);

digitalWrite (light3, LOW);
digitalWrite (light6, bajo);
Delay(s);
digitalWrite (light3, HIGH);
digitalWrite (light6, HIGH);

digitalWrite (light4, LOW);
digitalWrite (light5, bajo);
Delay(1050);
digitalWrite (light4, HIGH);
digitalWrite (light5, HIGH);

digitalWrite (light1, LOW);
digitalWrite (light8, bajo);
Delay(s);
digitalWrite (light1, HIGH);
digitalWrite (light8, HIGH);

digitalWrite (light2, LOW);
digitalWrite (light7, bajo);
Delay(q);
digitalWrite (light2, HIGH);
digitalWrite (light7, HIGH);

digitalWrite (light3, LOW);
digitalWrite (light6, bajo);
Delay(q);
digitalWrite (light3, HIGH);
digitalWrite (light6, HIGH);

digitalWrite (light4, LOW);
digitalWrite (light5, bajo);
Delay(DQ);
digitalWrite (light4, HIGH);
digitalWrite (light5, HIGH);

digitalWrite (light1, LOW);
digitalWrite (light2, LOW);
digitalWrite (light7, bajo);
digitalWrite (light8, bajo);
Delay(e);
digitalWrite (light1, HIGH);
digitalWrite (light2, HIGH);
digitalWrite (light7, HIGH);
digitalWrite (light8, HIGH);

digitalWrite (light2, LOW);
digitalWrite (light3, LOW);
digitalWrite (light6, bajo);
digitalWrite (light7, bajo);
Delay(DQ);
digitalWrite (light2, HIGH);
digitalWrite (light3, HIGH);
digitalWrite (light6, HIGH);
digitalWrite (light7, HIGH);

digitalWrite (light3, LOW);
digitalWrite (light4, LOW);
digitalWrite (light5, bajo);
digitalWrite (light6, bajo);
Delay(DQ);
digitalWrite (light3, HIGH);
digitalWrite (light4, HIGH);
digitalWrite (light5, HIGH);
digitalWrite (light6, HIGH);

digitalWrite (light1, LOW);
digitalWrite (light2, LOW);
digitalWrite (light3, LOW);
digitalWrite (light4, LOW);
digitalWrite (light5, bajo);
digitalWrite (light6, bajo);
digitalWrite (light7, bajo);
digitalWrite (light8, bajo);
Delay(DQ);
digitalWrite (light1, HIGH);
digitalWrite (light2, HIGH);
digitalWrite (light3, HIGH);
digitalWrite (light4, HIGH);
digitalWrite (light5, HIGH);
digitalWrite (light6, HIGH);
digitalWrite (light7, HIGH);
digitalWrite (light8, HIGH);
8100

digitalWrite (light8, bajo);
Delay(e);
digitalWrite (light8, HIGH);

digitalWrite (light1, LOW);
Delay(e);
digitalWrite (light1, HIGH);

digitalWrite (light7, bajo);
Delay(e);
digitalWrite (light7, HIGH);

digitalWrite (light2, LOW);
Delay(e);
digitalWrite (light2, HIGH);

digitalWrite (light6, bajo);
Delay(e);
digitalWrite (light6, HIGH);

digitalWrite (light3, LOW);
Delay(de);
digitalWrite (light3, HIGH);

digitalWrite (light5, bajo);
Delay(s);
digitalWrite (light5, HIGH);

digitalWrite (light4, LOW);
Delay(e);
digitalWrite (light4, HIGH);