La memoria, en sentido general, es una función del cerebro y a la misma vez un proceso psíquico que nos permite codificar, almacenar y posteriormente recuperar la información o las vivencias. La memoria surge como resultado de las conexiones sinápticas entre neuronas que, a lo largo del tiempo, crean una serie de redes neuronales de forma que los recuerdos se mantienen relativamente estables en el tiempo.

La memoria es el único paraíso del que no podemos ser expulsados.
(Jean Paul)

En relación con el alcance temporal de la memoria ésta se clasifica en: memoria a corto plazo, a mediano plazo y a largo plazo.

La memoria a corto plazo tiene una capacidad muy limitada, tanto en volumen de almacenamiento como en tiempo de permanencia. La información se puede mantener en la memoria a corto plazo mediante la repetición.

Por ejemplo, cuando nos dicen un número de teléfono y lo vamos repitiendo hasta encontrar un papel donde apuntarlo.

Si uno presta atención a esta información y la elabora (analiza, comprende, relaciona con otras ideas) puede pasar de la memoria a corto plazo a la memoria a largo plazo.

La memoria a largo plazo es prácticamente ilimitada tanto en capacidad como en duración.

La memoria a corto plazo, también denominada “memoria operativa”, es un sistema a partir del cual la persona maneja la información que se obtiene de una interacción directa con el ambiente que le rodea. Generalmente esta información se encuentra limitada a 7 elementos, con una variación de más o menos 2 ítems y puede mantenerse durante una media que oscila entre los 15 y los 30 segundos. No obstante, la memoria a corto plazo se verá más o menos limitada en relación con las capacidades de cada persona y el entrenamiento que ha realizado a lo largo de la vida.

Generalmente la memoria a corto plazo funciona a partir de tres principios muy sencillos: el efecto de primacía, el efecto de recencia y la significatividad.

El efecto de primacía hace referencia al hecho de que las personas recuerdan mejor las cosas que suceden inicialmente (ya sea los primeros ítems de una lista o las primeras palabras de una conversación). El efecto de recencia, al contrario, se refiere a nuestra excelente memoria para los hechos o datos que se presentan al final de una lista o una situación. Así, la tendencia de la memoria a corto plazo será la de transferir a la memoria a largo plazo los datos primeros o últimos; obviando buena parte de los hechos o datos intermedios. No obstante, si las informaciones intermedias tienen un gran significado emocional para las personas, entonces éstas adquirirán la primacía absoluta.

La memoria a corto plazo cumple varias funciones:

  • Retención de la información por un periodo corto de tiempo.
  • Apoyo al aprendizaje del nuevo conocimiento.
  • Comprensión del ambiente.
  • Facilitación del proceso de solución de problemas.

En esta ocasión crearemos un juego con Arduino para entrenar y mejorar el rendimiento de nuestra memoria a corto plazo.

El circuito esquemático de este juego de entrenamiento de la memoria se observa en la siguiente imagen:

Lista de Componentes
5 Resistencias 10KΩ 0.25W
4 Resistencias 390Ω 0.25W
1 LED 5mm Azul [Alto brillo]
1 LED 5mm Amarillo [Alto brillo]
1 LED 5mm Verde [Alto brillo]
1 LED 5mm Rojo [Alto brillo]
4 Pulsadores N.A. o Push-Button N.A.
1 Transistor NPN 2SC1815
1 Buzzer Pasivo 5V
1 Placa Arduino Nanino

/*
  Memory Game with Arduino
  Based on a project by Jeremy Wilson
  Modified by Rui Santos
  Visit: http://randomnerdtutorials.com
*/

#define BLUE_BUTTON     2
#define YELLOW_BUTTON   3
#define GREEN_BUTTON    4
#define RED_BUTTON      5
#define BLUE_LED        7
#define YELLOW_LED      8
#define GREEN_LED       9
#define RED_LED         10
#define BUZZER          12

// Constants
const int tones[] = {1915, 1700, 1519, 1432, 2700}; // tones when you press the LED's - the last one is when you fail.

// Variables
int buttonState[] = {0, 0, 0, 0};         // current state of the button
int lastButtonState[] = {0, 0, 0, 0};     // previous state of the button
int buttonPushCounter[] = {0, 0, 0, 0};
int game_on = 0;
int wait = 0;
int currentlevel = 1; // This is the level (also the number of button presses to pass to next level)
int rando = 0; //initialize random integer for loopgame_on. Will be from 1-4 later.
int butwait = 500; //amount of time to wait for next button input (ghetto de-bounce)
int ledtime = 500; //amount of time each LED flashes for when button is pressed
int n_levels = 10; //number of levels until the game is won
int pinandtone = 0; //This integer is used when the sequence is displayed
int right = 0; //This variable must be 1 in order to go to the next level
int speedfactor = 5; //This is the final speed of the lights and sounds for the last level. This increases as more games are won
int leddelay = 200; //Initializing time for LED. This will decrease as the level increases

long rand_num = 0; //initialize long variable for random number from 0-100.

void playTone(int tone, int duration) {
    for(long i = 0; i < duration * 1000L; i += tone * 2) {
        digitalWrite(BUZZER, HIGH);
        delayMicroseconds(tone);
        digitalWrite(BUZZER, LOW);
        delayMicroseconds(tone);
    }
}

void setup() {
    // initialize inputs:
    randomSeed(analogRead(0));
    pinMode(BLUE_BUTTON, INPUT);
    pinMode(YELLOW_BUTTON, INPUT);
    pinMode(GREEN_BUTTON, INPUT);
    pinMode(RED_BUTTON, INPUT);

    // initialize outputs:
    pinMode(BLUE_LED, OUTPUT);
    pinMode(YELLOW_LED, OUTPUT);
    pinMode(GREEN_LED, OUTPUT);
    pinMode(RED_LED, OUTPUT);
    pinMode(BUZZER, OUTPUT);
}

void loop() {

    int n_array[n_levels];
    int u_array[n_levels];
    int i;

    //clears arrays both "n_array" and "u_array" and starts a new game
    if(game_on == 0) {
        for(i = 0; i < n_levels; i = i + 1) {
            n_array[i] = 0;
            u_array[i] = 0;
            rand_num = random(1, 200);

            if(rand_num <= 50)
                rando = 0;
            else if(rand_num > 50 && rand_num <= 100)
                rando = 1;
            else if(rand_num > 100 && rand_num <= 150)
                rando = 2;
            else if(rand_num <= 200)
                rando = 3;
            //saves a random number in our n_array
            n_array[i] = rando;
        }
        game_on = 1;
    }

    //shows the user the current sequence
    if(wait == 0) {
        delay(200);
        i = 0;

        for(i = 0; i < currentlevel; i = i + 1) {
            leddelay = ledtime/(1+(speedfactor/n_levels)*(currentlevel - 1));
            pinandtone = n_array[i];
            digitalWrite(pinandtone+7, HIGH);
            playTone(tones[pinandtone], leddelay);
            digitalWrite(pinandtone+7, LOW);
            delay(100/speedfactor);
        }
        wait = 1;
    }

    i = 0;
    int buttonchange = 0;
    int j = 0; // This is the current position in the sequence

    while(j < currentlevel) {
        while(buttonchange == 0) {
            for(i = 0; i < 4; i = i + 1) {
            buttonState[i] = digitalRead(i + 2);
            buttonchange = buttonchange + buttonState[i];
            }
        }
        for(i = 0; i < 4; i = i + 1) {
            if(buttonState[i] == HIGH) {
                digitalWrite(i+7, HIGH);
                playTone(tones[i], ledtime);
                digitalWrite(i+7, LOW);
                wait = 0;
                u_array[j] = i;
                buttonState[i] = LOW;
                buttonchange = 0;
            }
        }
        if(u_array[j] == n_array[j]) {
            j++;
            right = 1;
        }
        else {
            right = 0;
            i = 4;
            j = currentlevel;
            wait = 0;
        }
    }

    if(right == 0) {
        delay(300);
        i = 0;
        game_on = 0;
        currentlevel = 1;
        for(i = 0; i < 4; i = i + 1) {
            digitalWrite(i + 7, HIGH);
        }
        playTone(tones[4], ledtime);
        for(i = 0; i < 4; i = i + 1) {
            digitalWrite(i + 7, LOW);
        }
        delay(200);
        for(i = 0; i < 4; i = i + 1) {
            digitalWrite(i+7, HIGH);
        }
        playTone(tones[4], ledtime);
        for(i = 0; i < 4; i = i + 1) {
            digitalWrite(i + 7, LOW);
        }

        delay(500);
        game_on = 0;
    }

    //if you insert the right sequence it levels up
    if(right == 1) {
        currentlevel++;
        wait = 0;
    }

    //if you finish the game
    if(currentlevel == n_levels) {
        delay(500);
        // The following is the victory sound:

        int notes[] = {2, 2, 2, 2, 0, 1, 2, 1, 2};
        int note = 0;
        int tempo[] = {200, 200, 200, 400, 400, 400, 200, 200, 600};
        int breaks[] = {100, 100, 100, 200, 200, 200, 300, 100, 200};

        for(i = 0; i < 9; i = i + 1) {
            note = notes[i];
            digitalWrite(note + 7, HIGH);
            playTone(tones[note], tempo[i]);
            digitalWrite(note + 7, LOW);
            delay(breaks[i]);
        }

        //sets game_on to 0, so it restarts a new game
        game_on = 0;
        currentlevel = 1;
        n_levels = n_levels + 2;
        speedfactor = speedfactor + 1;
    }
}

(click para ampliar)

(click para ampliar)

  • Agradecimientos: A mi prometida por haber grabado el siguiente video demo, por su tolerancia y comprensión. Sin ella nada de esto sería posible. TE AMO POR Y PARA SIEMPRE M.L.V!!! ❤ ❤ ❤ ❤
  • Anuncios

    Responder

    Por favor, inicia sesión con uno de estos métodos para publicar tu comentario:

    Logo de WordPress.com

    Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

    Imagen de Twitter

    Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

    Foto de Facebook

    Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

    Google+ photo

    Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

    Conectando a %s