Simon el pulpo (2 / 4 paso)

Paso 2: código

- Utilizamos el zumbador, LED, y botones que se incluyeron con la lillypad.

Para conseguir el zumbador para trabajar son dos llamadas que usted necesite: tone() y noTone().
Como una nota rápida la función tone() interfiere con la salida PWM en las patillas 3 y 11 excepto en la Mega.
La definición de la función de tono es:
tono (pin, frecuencia) o (pin, frecuencia, duración)
Si la duración no se especifica que el tono continuará jugando hasta que se llama la función noTone()
aplicado al pin. La definición de función de noTone() es simplemente noTone(pin).
Sólo puede reproducir un tono en el perno a la vez, esto no era un problema para nosotros porque
hemos utilizado un tono por la pierna.

Nuestra idea original era utilizar cada pierna en una nota diferente en la tonalidad de C y tienen
un octive todo. Desafortunadamente, no se usan las 8 patas para esto, pero con la
hardware adecuado que necesitará realizar algunos cambios de centro comercial en el código siguiente
tener que trabajar.

Hay un archivo de encabezado bonito que se incluye en el paquete de arduino que define
Tenga en cuenta todas las frecuencias para el correspondiente nombre. Una vez este archivo de encabezado
incluye todo lo que necesitas hacer es llamada NOTE_C4 que tenga el zumbador jugar C media o
Si usted necesita un agudo apenas Inserte de ' entre el nombre y el número es decir,
NOTE_GS4.

En nuestro código a continuación te darás cuenta que estamos utilizando un pin analógico por uno de los
botones de la pierna. Tuvimos que hacerlo basado en el diseño de lillypad así como el total
número de pernos que estábamos usando. Teníamos que hacer unos pequeños hacks para conseguirlo a
como los pines digitales que sólo puede comprobar para ver si el pin es alta o baja mientras
las salidas analógicas su voltaje.

Para cada pata hay un botón y una luz. Cuando se presiona el botón asignado
Nota se activa a través de la clavija de sonido y reproduce a través del zumbador, así
como el LED en la iluminación de la pierna.

Cuando ganas la primera parte del jardín del pulpo Beatles juega seguido por
la letra V. La canción fue realizada por colocar las notas en un arreglo y colocación sobre
esa matriz cuando es el momento adecuado.

El juego es relativamente simple. Al inicio de cada ciclo comprobamos todos los botones
a ver si alguno de ellos se presionan. Hicimos esto con llamadas a digitalRead(). Nosotros entonces 'bucle'
a través de los botones y si hay un botón que se activa una variable que
almacena el pasador más reciente. Sólo comprobamos uno tras otro así que si usted tenía los pernos
1 y 4 se presiona al mismo tiempo establecería la variable al pin 4.

Entonces tomamos esa información y pasarla en una instrucción switch que activa
la luz y el sonido asociado a la tecla pulsada. Debido a la forma en
Set todo para arriba no múltiples piernas de luz o reproducir varios sonidos. Que
sería una buena mejora a este proyecto. Si ha agregado 3 zumbadores que podría
acordes básicos mayores y menores apretando las piernas diferentes. Esto añadiría un
música en tiempo real que hace aspecto al pulpo. También con 8 patas tiene todos
las notas que necesita para reproducir canciones básicas en la tonalidad de C.

Para el aspecto de juego del código después de cada iteración del bucle principal comprobamos
que estamos en el modo de simon y que el estado de botón ha cambiado (un botón había sido
presiona). Comprueba el valor del botón y lo compara con el valor guardado en un array
que describe la secuencia de juego hasta ahora. Si los valores coinciden con lo agrega un nuevo valor
al final de la secuencia y juega todo el había actualizado secuencia desde el principio.
Si los valores no coinciden con lo entra en el bucle 'Pierdes' que juega de un perdedor
secuencia de la luz y se reinicia el juego.

#include "pitches.h"

int modo = 0; 0-Simon... 1-sonidos y luces

const int leg0B = A4;
const int leg0L = 13;
const int leg1B = 2;
const int leg1L = 3;
const int leg2B = 12;
const int leg2L = 11;
const int leg3B = 6;
const int leg3L = 7;
const int soundPin = 9;

int buttonState0 = 0;
int buttonState1 = 0;
int buttonState2 = 0;
int buttonState3 = 0;

int pauseBetweenNotes = 300;
Juego int = 500; al reproducir la secuencia de simon

int pinsUsed = 4;
int lastPin = 0;
int currentPin = -1;

int lastLight = 0;

const int maxTurns = 50;
juego int [maxTurns];
int vuelta = 0;
int arrayCounter = 0;

const int turnsToWin = 4;

loseTime largo sin firmar;
currentTime largo sin firmar;
delayAllowed largo sin signo = 10000; un botón dentro de 4 segundos o pierdes

Notas de la melodía:
F Sharp G C D
melodía de int [] = {}
NOTE_B4, NOTE_B4, NOTE_CS4, NOTE_B4, NOTE_B0,
NOTE_GS4, NOTE_GS4, NOTE_A4, NOTE_GS4,
NOTE_GS4, NOTE_FS4, NOTE_E4, NOTE_E4, NOTE_E4,
NOTE_CS4, NOTE_B4, NOTE_GS4, NOTE_E4, NOTE_GS4,
NOTE_FS4
};

Tenga en cuenta las duraciones: 4 = cuarto nota, 8 = corchea, etc..:
int noteDurations [] = {}
4, 4, 4, 1, 4,
4, 4, 4, 1,
8, 8, 4, 4, 4,
4, 4, 2, 8, 8, 1};

void setup() {}
/*
para (int thisNote = 0; thisNote < 20; thisNote ++) {}

para calcular la duración de la nota, tomar un segundo
dividido por el tipo de nota.
por ejemplo, trimestre Nota = 1000 / 4, corchea = 1000/8, etc..
int noteDuration = 1000/noteDurations [thisNote];
tono (soundPin, melody[thisNote],noteDuration);

para distinguir las notas, establecer un tiempo mínimo entre ellos.
duración + 30% de la nota parece que funciona bien:
int pauseBetweenNotes = noteDuration * 1.30;
Delay(pauseBetweenNotes);
detener la reproducción de tono:
noTone(soundPin);

}
*/

Serial.Begin(9600);
Millis(); inicializar los pernos de legxB como una entrada:
pinMode (leg0B, entrada);
pinMode (leg1B, entrada);
pinMode (leg2B, entrada);
pinMode (leg3B, entrada);
pinMode (leg4B, entrada);
pinMode (leg5B, entrada);
pinMode (leg6B, entrada);
pinMode (leg7B, entrada);
inicializar el LED como salida:
pinMode (leg0L, salida);
pinMode (leg1L, salida);
pinMode (leg2L, salida);
pinMode (leg3L, salida);
pinMode (leg4L, salida);
pinMode (leg5L, salida);
pinMode (leg6L, salida);
pinMode (leg7L, salida);
inicializar el conector de sonido como salida:
pinMode (soundPin, salida);
para distinguir las notas, establecer un tiempo mínimo entre ellos.
duración + 30% de la nota parece que funciona bien:
int pauseBetweenNotes = noteDuration * 1.30;

juego [0] = -1;
}

void loop() {}

detectar la tecla presionada
buttonState0 = analogRead(leg0B);
Serial.println(buttonState0);
buttonState1 = digitalRead(leg1B);
buttonState2 = digitalRead(leg2B);
buttonState3 = digitalRead(leg3B);
/*
buttonState4 = digitalRead(leg4B);
buttonState5 = digitalRead(leg5B);
buttonState6 = digitalRead(leg6B);
buttonState7 = digitalRead(leg7B);
*/
Set var basado en el pulsador
currentPin = -1; -1 si ningún botón
if(buttonState0 == High)
if(buttonState0 > 200)
currentPin = 0;
if(buttonState1 == High)
currentPin = 1;
if(buttonState2 == High)
currentPin = 2;
if(buttonState3 == High)
currentPin = 3;
Serial.println(currentPin);
/*
if(buttonState4 == High)
currentPin = 4;
if(buttonState5 == High)
currentPin = 5;
if(buttonState6 == High)
currentPin = 6;
if(buttonState7 == High)
currentPin = 7;
*/
currentTime = millis();
loseTime = millis() + delayAllowed;

Si (modo == 0 & & currentTime > loseTime)
{
gameLost(0);
}

Si (modo == 0 & & juego [0] == -1)
{
Serial.println ("empezar juego");
vuelta = 0;
addRound();
}

Si (currentPin! = lastPin)
{
digitalWrite (lastLight, bajo);
Si (modo == 0 & & currentPin! = -1) modo de //simon
{
Si (juego [arrayCounter]! = currentPin)
{
gameLost(1);
currentPin = -1;
}
otra cosa
{
arrayCounter ++;
currentTime = millis();
loseTime = millis() + delayAllowed;

}
}

interruptor (currentPin) {}
caso -1:
noTone(soundPin);
Serial.println ("caso de -1");
rotura;
caso 0:
Serial.println ("caso 0");
reproducir sonido en pierna 0 así como ilumina la pierna
digitalWrite (leg0L, HIGH);
lastLight = leg0L;
tono (soundPin, NOTE_C4);
Delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, bajo);
rotura;
caso 1:
Serial.println ("caso 1");
reproducir sonido en pata 1 como luz encima de la pierna
digitalWrite (leg1L, HIGH);
lastLight = leg1L;
tono (soundPin, NOTE_D4);
Delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg1L, bajo);
rotura;
caso 2:
Serial.println ("caso 2");
reproducir sonido en pata 2 y luz encima de la pierna
digitalWrite (leg2L, HIGH);
lastLight = leg2L;
tono (soundPin, NOTE_E4);
Delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg2L, bajo);
rotura;
caso 3:
Serial.println ("caso 3");
reproducir sonido en pata 3 como luz encima de la pierna
digitalWrite (leg3L, HIGH);
lastLight = leg3L;
tono (soundPin, NOTE_F4);
Delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg3L, bajo);
rotura;
/*
caso 4:
reproducir sonido en pata 4 y luz encima de la pierna
digitalWrite (leg4L, HIGH);
lastLight = leg4L;
tono (soundPin, NOTE_G4);
Delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg4L, bajo);
rotura;
caso 5:
reproducir sonido en pata 5 como luz encima de la pierna
digitalWrite (leg5L, HIGH);
lastLight = leg5L;
tono (soundPin, NOTE_A4);
Delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg5L, bajo);
rotura;
caso 6:
reproducir sonido en pata 6 como luz encima de la pierna
digitalWrite (leg6L, HIGH);
lastLight = leg6L;
tono (soundPin, NOTE_B4);
Delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg6L, bajo);
rotura;
caso 7:
reproducir sonido en pata 7 como luz encima de la pierna
digitalWrite (leg7L, HIGH);
lastLight = leg7L;
tono (soundPin, NOTE_C5);
Delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg7L, bajo);
rotura;
*/
por defecto:
Si nada más los partidos, no el valor por defecto
por defecto es opcional
}
lastPin = currentPin;

Si (arrayCounter > = vuelta)
{
Delay(500);
digitalWrite (lastLight, bajo);
noTone(soundPin);
Delay(1000);
addRound();
}
}
Delay(100);
}

void playSequence()
{
Serial.println("playSequence");
int seqCounter = 0;
int valor = juego [seqCounter];
int noteLength = 1000-(100*turn);
if(noteLength < 500)
{
noteLength = 500;
}
mientras (valor! = -1)
{
Switch (valor) {}
caso 0:
reproducir sonido en pierna 0 así como ilumina la pierna
digitalWrite (leg0L, HIGH);
tono (soundPin, NOTE_C4);
Delay(noteLength);
noTone(soundPin);
digitalWrite (leg0L, bajo);
rotura;
caso 1:
reproducir sonido en pata 1 como luz encima de la pierna
digitalWrite (leg1L, HIGH);
tono (soundPin, NOTE_D4);
Delay(noteLength);
noTone(soundPin);
digitalWrite (leg1L, bajo);
rotura;
caso 2:
reproducir sonido en pata 2 y luz encima de la pierna
digitalWrite (leg2L, HIGH);
tono (soundPin, NOTE_E4);
Delay(noteLength);
noTone(soundPin);
digitalWrite (leg2L, bajo);
rotura;
caso 3:
reproducir sonido en pata 3 como luz encima de la pierna
digitalWrite (leg3L, HIGH);
tono (soundPin, NOTE_F4);
Delay(noteLength);
noTone(soundPin);
digitalWrite (leg3L, bajo);
rotura;
/*
caso 4:
reproducir sonido en pata 4 y luz encima de la pierna
digitalWrite (leg4L, HIGH);
tono (soundPin, NOTE_G4);
Delay(noteLength);
noTone(soundPin);
digitalWrite (leg4L, bajo);
rotura;
caso 5:
reproducir sonido en pata 5 como luz encima de la pierna
digitalWrite (leg5L, HIGH);
tono (soundPin, NOTE_A4);
Delay(noteLength);
noTone(soundPin);
digitalWrite (leg5L, bajo);
rotura;
caso 6:
reproducir sonido en pata 6 como luz encima de la pierna
digitalWrite (leg6L, HIGH);
tono (soundPin, NOTE_B4);
Delay(noteLength);
noTone(soundPin);
digitalWrite (leg6L, bajo);
rotura;
caso 7:
reproducir sonido en pata 7 como luz encima de la pierna
digitalWrite (leg7L, HIGH);
tono (soundPin, NOTE_C5);
Delay(noteLength);
noTone(soundPin);
digitalWrite (leg7L, bajo);
romper; * /
}
seqCounter ++;
valor = juego [seqCounter];
Delay(pauseBetweenNotes);
}
}

void addRound()
{
Serial.Print ("giro añadiendo");
Serial.println(Turn);
tiempo siguiente = random(pinsUsed);
if(Turn > turnsToWin)
{
gameWon();
currentPin = -1;
lastPin = -1;
}
otra cosa
{
juego [turno] = siguiente;
juego [vuelta + 1] = -1;
a su vez ++;
playSequence();
arrayCounter = 0;
currentTime = millis();
loseTime currentTime = delayAllowed;
Serial.Print ("perder tiempo y tal -");
Serial.println(loseTime);
Serial.Print ("hora actual -");
Serial.println(currentTime);
}
}

void gameWon()
{

para (int thisNote = 0; thisNote < 20; thisNote ++) {}

}
Delay(10);

digitalWrite (leg0L, HIGH);
digitalWrite (leg1L, HIGH);
digitalWrite (leg2L, HIGH);
digitalWrite (leg3L, HIGH);
tono (soundPin, NOTE_C4);
Delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, bajo);
digitalWrite (leg1L, bajo);
digitalWrite (leg2L, bajo);
digitalWrite (leg3L, bajo);
Delay(pauseBetweenNotes);

digitalWrite (leg0L, HIGH);
digitalWrite (leg1L, HIGH);
digitalWrite (leg2L, HIGH);
digitalWrite (leg3L, HIGH);
tono (soundPin, NOTE_C4);
Delay(pauseBetweenNotes);
Delay(pauseBetweenNotes);
Delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, bajo);
digitalWrite (leg1L, bajo);
digitalWrite (leg2L, bajo);
digitalWrite (leg3L, bajo);
Delay(pauseBetweenNotes);
Delay(3000);
gameReset();

}

void gameLost(int i)
{
S
digitalWrite (leg0L, HIGH);
digitalWrite (leg1L, HIGH);
digitalWrite (leg2L, HIGH);
digitalWrite (leg3L, HIGH);
tono (soundPin, NOTE_C4);
Delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, bajo);
digitalWrite (leg1L, bajo);
digitalWrite (leg2L, bajo);
digitalWrite (leg3L, bajo);
Delay(pauseBetweenNotes);

O
digitalWrite (leg0L, HIGH);
digitalWrite (leg1L, HIGH);
digitalWrite (leg2L, HIGH);
digitalWrite (leg3L, HIGH);
tono (soundPin, NOTE_C4);
Delay(pauseBetweenNotes);
Delay(pauseBetweenNotes);
Delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, bajo);
digitalWrite (leg1L, bajo);
digitalWrite (leg2L, bajo);
digitalWrite (leg3L, bajo);
Delay(pauseBetweenNotes);

S
digitalWrite (leg0L, HIGH);
digitalWrite (leg1L, HIGH);
digitalWrite (leg2L, HIGH);
digitalWrite (leg3L, HIGH);
tono (soundPin, NOTE_C4);
Delay(pauseBetweenNotes);
noTone(soundPin);
digitalWrite (leg0L, bajo);
digitalWrite (leg1L, bajo);
digitalWrite (leg2L, bajo);
digitalWrite (leg3L, bajo);
Delay(pauseBetweenNotes);

}

Vea el paso

Choque de todo el mundo en Halloween con este disfraz de Medusa DIY hacer un chapoteo grande este Halloween con este un único do-it-yourselfer!Paso 1: Halloween es su una noche del año par ...
Instructables Domo Pizza pizzas artísticas, no artesanales pizzas. Maneras de dar forma y decorar tu pizza con tus personajes favoritos o aderezo ...
FLORERO de palos de paletas Estoy trabajando fuera de mi estado natal. A finales de este mes voy a mi casa. Así que pensé que si regalo algo a mi ma ...
Construcción de dos barcos de estilo portugués (pequeñas embarcaciones) este proyecto abarca la construcción de dos lanchas que se construyen principalmente con tres hojas de madera contrachap ...
Ajedrez de tornillo! o mejor figuras de ajedrez de tornillos Hola mundo,OK primero instructable así que perdonar los errores de novato.Este lo hice el año pasado en enero y realment ...