Symons Says

pitches.h

/*************************************************
 * Public Constants
 *************************************************/
 #define NOTE_B0  31
 #define NOTE_C1  33
 #define NOTE_CS1 35
 #define NOTE_D1  37
 #define NOTE_DS1 39
 #define NOTE_E1  41
 #define NOTE_F1  44
 #define NOTE_FS1 46
 #define NOTE_G1  49
 #define NOTE_GS1 52
 #define NOTE_A1  55
 #define NOTE_AS1 58
 #define NOTE_B1  62
 #define NOTE_C2  65
 #define NOTE_CS2 69
 #define NOTE_D2  73
 #define NOTE_DS2 78
 #define NOTE_E2  82
 #define NOTE_F2  87
 #define NOTE_FS2 93
 #define NOTE_G2  98
 #define NOTE_GS2 104
 #define NOTE_A2  110
 #define NOTE_AS2 117
 #define NOTE_B2  123
 #define NOTE_C3  131
 #define NOTE_CS3 139
 #define NOTE_D3  147
 #define NOTE_DS3 156
 #define NOTE_E3  165
 #define NOTE_F3  175
 #define NOTE_FS3 185
 #define NOTE_G3  196
 #define NOTE_GS3 208
 #define NOTE_A3  220
 #define NOTE_AS3 233
 #define NOTE_B3  247
 #define NOTE_C4  262
 #define NOTE_CS4 277
 #define NOTE_D4  294
 #define NOTE_DS4 311
 #define NOTE_E4  330
 #define NOTE_F4  349
 #define NOTE_FS4 370
 #define NOTE_G4  392
 #define NOTE_GS4 415
 #define NOTE_A4  440
 #define NOTE_AS4 466
 #define NOTE_B4  494
 #define NOTE_C5  523
 #define NOTE_CS5 554
 #define NOTE_D5  587
 #define NOTE_DS5 622
 #define NOTE_E5  659
 #define NOTE_F5  698
 #define NOTE_FS5 740
 #define NOTE_G5  784
 #define NOTE_GS5 831
 #define NOTE_A5  880
 #define NOTE_AS5 932
 #define NOTE_B5  988
 #define NOTE_C6  1047
 #define NOTE_CS6 1109
 #define NOTE_D6  1175
 #define NOTE_DS6 1245
 #define NOTE_E6  1319
 #define NOTE_F6  1397
 #define NOTE_FS6 1480
 #define NOTE_G6  1568
 #define NOTE_GS6 1661
 #define NOTE_A6  1760
 #define NOTE_AS6 1865
 #define NOTE_B6  1976
 #define NOTE_C7  2093
 #define NOTE_CS7 2217
 #define NOTE_D7  2349
 #define NOTE_DS7 2489
 #define NOTE_E7  2637
 #define NOTE_F7  2794
 #define NOTE_FS7 2960
 #define NOTE_G7  3136
 #define NOTE_GS7 3322
 #define NOTE_A7  3520
 #define NOTE_AS7 3729
 #define NOTE_B7  3951
 #define NOTE_C8  4186
 #define NOTE_CS8 4435
 #define NOTE_D8  4699
 #define NOTE_DS8 4978

SymonsSays

#include "pitches.h"
    
/* PINES DE ENTRADA
 * [2-6] pines de entrada (push-button), 2 = start
 * [23] potenciometro (Velocidad).
 * [24-27] pines de salidas para LEDs
 * Pin 40 Salida Analoga para bocina 
 */
 
const int potentiometerPin = 23;
const int buzzerPin = 40; 

const int startPin = 2;

//LEDS
const int firstLed = 24;
const int secondLed = 25;
const int thirdLed = 26;
const int fourthLed = 27;

//PUSH
const int firstPush = 3;
const int secondPush = 4;
const int thirdPush = 5;
const int fourthPush = 6;

//USER VALIDATE
const int sequencesByLevel = 5;
int currentSequence;
int currentMemberSequence;


boolean started;
boolean waitingForUser = false;

int sequencesLevel[sequencesByLevel][10];
int currentLevel = 1;
int currentSequenceElement = 0;
int sleepTime = 1000;

void clearLastStates() {
    digitalWrite(firstLed, LOW);
    digitalWrite(secondLed, LOW);
    digitalWrite(thirdLed, LOW);
    digitalWrite(fourthLed, LOW);
}

void makeLevelSequences() {
    //La secuencia se crea en base a el nivel con "nS" leds por secuencia.
    int nS = 2 + ((currentLevel > 2) ? (currentLevel + 3) : currentLevel);
    for (int i = 0 ; i < sequencesByLevel ; i++) {
        for (int j = 0; j < 10 ; j++) {
            if (j < nS) {
                sequencesLevel[i][j] = random(1,5);
            } else {
                sequencesLevel[i][j] = 0;
            }
        }
    }
}

void showCurrentSequence() {
    for (int i = 0; i < 10 ; i++) {
        int value = sequencesLevel[currentSequence][i];
        if (value == 0)
            return;
        
        int pin;
        switch (value) {
        case 1:
            pin = firstLed;
            break;
        case 2:
            pin = secondLed;
            break;
        case 3:
            pin = thirdLed;
            break;
        case 4:
            pin = fourthLed;
            break;          
        }
        digitalWrite(pin, HIGH);
        Serial.println(value);
        delay(sleepTime);
        digitalWrite(pin, LOW);
        delay(100);
    }
}

void sweep() {
    digitalWrite(firstLed, HIGH);
    sleep(400);
    digitalWrite(firstLed, LOW);
    digitalWrite(secondLed, HIGH);
    sleep(400);
    digitalWrite(secondLed, LOW);
    digitalWrite(thirdLed, HIGH);
    sleep(400);
    digitalWrite(thirdLed, LOW);
    digitalWrite(fourthLed, HIGH);
    sleep(400);
    digitalWrite(fourthLed, LOW);
}

void turnOnAll() {
    digitalWrite(firstLed, HIGH);
    digitalWrite(secondLed, HIGH);
    digitalWrite(thirdLed, HIGH);
    digitalWrite(fourthLed, HIGH);
    sleep(500);
    digitalWrite(firstLed, LOW);
    digitalWrite(secondLed, LOW);
    digitalWrite(thirdLed, LOW);
    digitalWrite(fourthLed, LOW);
}

void buzzer() {
    int melody[] = {NOTE_C4, NOTE_G3,NOTE_G3, NOTE_A3, NOTE_G3,0, NOTE_B3, NOTE_C4};
    // note durations: 4 = quarter note, 8 = eighth note, etc.:
    int noteDurations[] = {4,8,8,4,4,4,4,4 };

    // iterate over the notes of the melody:
    for (int thisNote = 0; thisNote < 8; thisNote++) {
        // to calculate the note duration, take one second 
        // divided by the note type.
        //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
        int noteDuration = 1000/noteDurations[thisNote];
        tone(buzzerPin, melody[thisNote],noteDuration);

        // to distinguish the notes, set a minimum time between them.
        // the note's duration + 30% seems to work well:
        int pauseBetweenNotes = noteDuration * 1.30;
        delay(pauseBetweenNotes);
        // stop the tone playing:
        noTone(buzzerPin);
    }
}

void fail() {
    buzzer();
    //Luces y sonido de fracaso
    sweep();
    sleep(500);
    sweep();
    
    //Reinicar juego
    currentLevel = 1;
    currentSequence = 0;
    currentMemberSequence = 0;
    makeLevelSequences();
    waitingForUser = false;
}

void win() {
    //Luces,sonido y danza de victora!
    buzzer();
    turnOnAll();
    sleep(500);
    turnOnAll();
    
    //Avanzar nivel
    if ((currentSequence + 1) == sequencesByLevel ) {
        currentMemberSequence = 0;
        currentSequence = 0;
        currentLevel++;
        makeLevelSequences();
    } else { 
        currentMemberSequence = 0;
        currentSequence++;
    }
    waitingForUser = false;
}

void validateUserSequence(int nLed) {
    if (sequencesLevel[currentSequence][currentMemberSequence] != nLed) {
        fail();    
    }
    
    //Va bien
    currentMemberSequence++;
    if (currentMemberSequence > 9) { //Llego al limite del array con todas correctas
        win();
    } else if (sequencesLevel[currentSequence][currentMemberSequence + 1] == 0) { //Llego al ultimo miembro de la secuencia
        win();
    }
}

void verifyInput(){
    if (digitalRead(firstPush) == LOW) {
        digitalWrite(firstLed, HIGH);
        validateUserSequence(1);
    } else {
        digitalWrite(firstLed, LOW);
    }
    
    if (digitalRead(secondPush) == LOW) {
        digitalWrite(secondLed, HIGH);
        validateUserSequence(2);
    } else {
        digitalWrite(secondLed, LOW);
    }
    
    if (digitalRead(thirdPush) == LOW) {
        digitalWrite(thirdLed, HIGH);
        validateUserSequence(3);
    } else {
        digitalWrite(thirdLed, LOW);
    }
    
    if (digitalRead(fourthPush) == LOW) {
        digitalWrite(fourthLed, LOW);
        validateUserSequence(4);
    } else {
        digitalWrite(fourthLed, LOW);
    }
}

void verifyVelocity(){
    //De 200ms a 5s => [200,5000] 
    double potentiometerValue = analogRead(potentiometerPin); 
    sleepTime = (potentiometerValue * 5000)/ 4095;
}

void setup(){
    Serial.println("SETUP");

    //Preparando pines de entrada. Push buttons
    pinMode(firstPush, INPUT);
    pinMode(secondPush, INPUT);
    pinMode(thirdPush, INPUT);
    pinMode(fourthPush, INPUT);
    pinMode(startPin, INPUT);
  
    //Preparando pines de salida, LEDs
    pinMode(firstLed, OUTPUT);
    pinMode(secondLed, OUTPUT);
    pinMode(thirdLed, OUTPUT);
    pinMode(fourthLed, OUTPUT);
 
    Serial.begin(9600);
    clearLastStates();   
}

void loop(){
    verifyVelocity();
    if (started) {
        if (!waitingForUser) {
            Serial.println("Encender Leds");
            showCurrentSequence();
            waitingForUser = true;
        } else {
            Serial.println();
            verifyInput();
        }
    } else {
        if (digitalRead(startPin) == LOW) {
            Serial.println("STARTING...");            
            started = true;
            makeLevelSequences();
        } 
    }
}