Paso 5: Arduino, protector de la onda de conocer.
Lo siento, que estoy divagando.
Aquí está lo que no vamos a mostrar: tres horas de soldadura! Lo grande acerca de Lady Ada y sus gloriosos productos es que son baratas y vienen con instrucciones muy buenas! Además, la dama, mantiene el coste por no montar los tableros y a su vez, se aprende a soldar como un robot! Qué es una mierda, la ruta de acceso de soldadura como un robot es afín el paseo de Dante tuvo con Virgilio.
No seas skerd! Soldar es una habilidad!
La siguiente cosa a hacer es seguir el tutorial "USE IT" en el protector de la onda para aprender cómo a... uh... usarlo. Trata usando la tarjeta FORMATTER y tarjeta SD, los archivos a la tarjeta y obtener el código! Nuestro código está publicado a continuación. ESTO ES PEDIR MUCHO DE UN NUEVO USUARIO DE ARDUINO!!!!!! No se desanime si no va sin problemas. No para nosotros tampoco.
Código: Abajo aquí, copiar y pegar en el IDE de Arduino.
#include "FatReader.h"
#include "SdReader.h"
#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 jugando
Ola WaveHC; Este es el único objeto (audio) de la onda, puesto que sólo jugaremos uno a la vez
dirLevel de uint8_t; aplicar sangría a nivel de nombres de archivo/dir (para prettyIndent)
dirBuf de dir_t; buffer para directorio lecturas
void setUsUpTheCard(void) {}
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!
}
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!
}
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 ("archivos encontrados:");
dirLevel = 0;
Imprima todos los archivos en los directorios.
lsR(root);
}
/*
* lista recursivamente - desbordamiento de pila posible si subdirectorios anidados demasiado
*/
void lsR (FatReader & d)
{
int8_t r; indica el nivel de recursividad
mientras que ((r = d.readDir(dirBuf)) > 0) {/ / lee el siguiente archivo en el directorio
saltar subdirectorios. y...
Si (dirBuf.name[0] == '.')
continuar;
para (uint8_t i = 0; i < dirLevel; i ++)
Serial.Print(' '); Esto es para prettyIndent, poner espacios en el frente
printName(dirBuf); imprimir el nombre del archivo que acaba de
Serial.println(); y una nueva línea
Si (DIR_IS_SUBDIR(dirBuf)) {/ / va efectuar recursividad en cualquier direcory
FatReader s; hacer un nuevo objeto de directorio que contienen la información
dirLevel += 2; guión 2 espacios para futuras impresiones
Si (s.open (vol, dirBuf))
lsR(s); listar todos los archivos en este directorio ahora!
dirLevel-=2; eliminar la sangría extra
}
}
sdErrorCheck(); ¿Estamos haciendo OK?
}
/*
* imprimir campo de nombre de dir_t. La salida es 8.3 formato, así como sonido. WAV o nombre de archivo. DAT
*/
void printName (dir_t & dir)
{
para (uint8_t me = 0; i < 11; i ++) {/ / formato 8.3 tiene 8 + 3 = 11 letras en él
Si (dir.name[i] == ' ')
continuar; no imprimir ningún espacio en el nombre
Si (i == 8)
Serial.Print('.'); después de la carta 8, colocar un punto
Serial.Print(Dir.Name[i]); la cifra de n'th de impresión
}
Si (DIR_IS_SUBDIR(dir))
Serial.Print('/'); directorios get / al final
}
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();
}
void sdErrorCheck(void)
{
Si (! card.errorCode()) retorno;
putstring ("error de E/S SD:");
Serial.Print(Card.ErrorCode(), hexagonal);
putstring (",");
Serial.println(Card.errorData(), hexagonal);
while(1);
}
/*************************************
TRATA LAS COSAS BUENAS ***
*************************************/
int tilt_port = 13; puerto digital sensor de la inclinación está en
int tilt_original; mantiene la posición de inicio del sensor de la inclinación
de acción del faux del acelerómetro
void setup() {}
Serial.Begin(9600);
pinMode (tilt_port, entrada);
int tilt_original = digitalRead(tilt_port);
setUsUpTheCard(); inicializar el protector de la onda
}
pulgar de int = 0;
puntero de int = 0;
int medio = 0;
anillo int = 0;
pinky de int = 0;
int tilt_waiting = 0;
int tilt_inmotion = 0;
rizado de int = 0;
int curled_previous = 0;
void loop() {}
pulgar de int = analogRead(A4);
puntero de int = analogRead(A3);
int medio = analogRead(A2);
anillo int = analogRead(A1);
pinky de int = analogRead(A0);
rizado = 0;
/*
* el pulgar parece ser b0rked
* al azar (?) pega en 0
* vamos a ignorarlo
*/
Si {} (pulgar > 120)
encrespada += 1;
}
Si {} (puntero > 150)
encrespada += 10;
}
/*
dedo medio está aparentemente siempre en
* vamos a ignorarlo
*/
Si (media > 130) {}
encrespada += 100;
}
Si {} (anillo > 170)
+= rizado 1000;
}
Si {} (pinky > 120)
+= rizado 10000;
}
Si (rizado > = 11100) {}
tilt_check ("PUNCH", "PUNCH. WAV");
} else {}
tilt_check ("Arma", "la pistola. WAV");
}
/*
Si (rizado == 0) {}
Karate CHOP!
tilt_check ("Picar", "CHOP. WAV");
} else if (rizado == 1000 + 10000) {}
PISTOLA
tilt_check ("Arma", "la pistola. WAV");
} else if (rizado == 9999) {}
SPIIIIIDEY-HOMBRE
tilt_check ("SPIDEY", "SPIDEY. WAV");
} else if (rizado == 10 + 1000 + 10000) {}
PUÑO DE
tilt_check ("PUNCH", "PUNCH. WAV");
}
*/
Serial.Print ("pulgar:"); Serial.println(Thumb);
Serial.Print ("puntero:"); Serial.println(Pointer);
Serial.Print ("media:"); Serial.println(Middle);
Serial.Print ("anillo:"); Serial.println(Ring);
Serial.Print ("pinky:"); Serial.println(Pinky);
Serial.Print ("rizado:"); Serial.println(Curled);
Serial.println("");
Delay(15);
}
void reset_check (int reset = 0) {}
Si (reset || encrespado! = curled_previous) {}
tilt_waiting = 0;
tilt_inmotion = 0;
curled_previous = rizado;
}
}
void tilt_check (String mensaje, char * nombre) {}
reset_check();
inclinación de int = digitalRead(tilt_port);
Serial.println(Tilt);
Si (! tilt_waiting) {}
tilt_waiting = 1;
tilt_original = inclinación;
} else {}
Si (inclinación! = tilt_original) {}
tilt_inmotion = 1;
}
Si (tilt_inmotion & & tilt == tilt_original) {}
Serial.println(Message);
Serial.println(FileName);
playcomplete(FileName);
reset_check(1);
}
}
}
