Se denominan sueños lúcidos a aquellos sueños en los que uno puede darse cuenta de que está soñando. Este tipo de experiencia onírica suele darse de forma espontánea, aunque también es posible inducirlos mediante ciertas prácticas, ejercicios o máquinas. La Lucid Dream Machine es un sencillo dispositivo que puedes construir para tener este tipo de experiencia cuando quieras.
Cien años de sueños lúcidos
El concepto de sueño lúcido está a punto de cumplir cien años. Fue el psiquiatra holandés Frederick van Eeden quien, en un estudio realizado en 1913, lo describió por primera vez. También el francés Hervey de Saint-Denys describió algo parecido, aunque sin darle ese nombre, en 1867. Hoy día se aceptan como un hecho comprobado científicamente.
Básicamente, se trata de una fase del sueño REM (por Rapid Eye Movement, o Movimiento Ocular Rápido), en la que se producen los sueños más intensos y vívidos. Durante un sueño lúcido, hay personas que pueden controlar su “argumento” a voluntad, llevando a cabo sus deseos en los mismos. Es posible cambiar el lugar donde se desarrolla el sueño, visitar lugares (conocidos o imaginarios), volar, y prácticamente cualquier cosa que se te ocurra. A las personas que son capaces de lograr este tipo de sueños se las denomina onironautas.
Cómo funciona la Lucid Dream Machine
La Lucid Dream Machine consiste en un par de gafas especiales, que debes utilizar mientras estás durmiendo. Dispone de un par de diodos LED, controlados por un microcontrolador, que comienzan a emitir pulsos de luz unas cuatro horas después de que te has dormido. Según dice su autor, el brillo de los LEDs a través de los párpados basta para, sin despertarte del todo, ayudarte a tomar conciencia de que estás soñando. Esto te proporciona una buena probabilidad de que seas capaz de controlar el curso del sueño.
El proyecto, publicado en instructables.com por el usuario guyfrom7up, puede construirse en un par de horas. Como tantos otros proyectos basados en microcontroladores que hemos publicado o desarrollado en NeoTeo, necesitarás emplear un grabador para enviar el programa desde el ordenador al chip que controla las luces.
El circuito es realmente sencillo. Tanto, que ni siquiera hace falta fabricar un PCB específico para montar los componentes (puedes usar un simple trozo de PCB para prototipos). Sin embargo, el autor se ha tomado el trabajo de diseñar uno, que puedes construir con el procedimiento que ya hemos explicado.
Lista de materiales
- 1x microcontrolador ATtiny13v AVR
- 2x LEDs (del color que prefieras)
- 2x resistores de 100 ohmios
- 1x llave de encendido SPST o SPDT
- 1x pulsador normalmente
- 1x batería de litio de 3 voltios (CR2032, por ejemplo)
- 1x porta batería
- 1x gafas para dormir o similares
El valor de los resistores que van en serie con los diodos LEDs es el que determinará el brillo máximo de estos. Si ponemos un valor menor que el sugerido, el brillo será mayor, y viceversa. No conviene utilizar resistores de menos de 47 ohmios, para preservar la vida útil de la pila o batería. De todos modos, su consumo es tan bajo que podremos utilizar la Lucid Dream Machine durante muchas semanas antes de que se agote.
El montaje del dispositivo electrónico sobre las gafas dependerá del tipo de antifaz que consigamos, y de lo habilidosos que seamos para la costura, aunque tampoco te debería costar demasiado trabajo llegar a buen puerto.
Cuando tengas todo montado y probado, te colocas el antifaz, ¡y a dormir! Es posible que las primeras noches no logres tener un sueño lúcido, o que lo tengas pero que no seas capaz de recordarlo al despertar. Pero seguramente luego de unas cuantas sesiones puedas soñar a voluntad.
Por supuesto, esperamos que nos cuentes tus experiencias.
Código fuente del microcontrolador
Hemos colocado aquí el código fuente del microcontrolador AVR, con los comentarios en español, por si quieres saber cómo funciona o realizar algún cambio. Está escrito en lenguaje C:
/********************************************* lucid13.c V 0.2b Lucid dreaming device Software by gmoon (Doug Garmon) Hardware by guyfrom7up (Brian _)
* Chip : ATtiny13
* Clock Internal, 1.2 Mhz
*********************************************/
#include <avr/io.h>
#include <inttypes.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#define F_CPU 1200000UL // Reloj a 1.2 MHz
// Datos del PWM
#define PWM_VAL 4
#define TRANS_VAL 6
// Duración y demoras entre pulsos
#define MACRO_WIDTH 1500
#define MACRO_GAP 1500
// Modo
#define MODE_WAITING 0
#define MODE_DREAM 1
#define WAIT_LENGTH 1
#define BUTTON PB4 // Pulsador
#define LED _BV(PB1) | _BV(PB2) // control de los LEDs
volatile uint16_t macropulse;
volatile uint16_t waitstate;
// vector IRQ
ISR (TIM0_OVF_vect)
{ static uint8_t modeflag; static uint8_t pwm; static uint16_t transition;
switch (modeflag) { case MODE_DREAM: if(macropulse < MACRO_WIDTH) { pwm += PWM_VAL; if (pwm > transition) PORTB &= ~(LED); // Apago LEDs else PORTB |= LED; // Enciendo LEDs if (!pwm) transition += TRANS_VAL; } // Demora entre pulsos else { pwm = transition = 0; PORTB &= ~(LED); // Apago LEDs if (macropulse > (MACRO_GAP + MACRO_WIDTH)) macropulse = 0; } macropulse++; break; case MODE_WAITING: macropulse++; if (!macropulse) waitstate++; if (waitstate >= WAIT_LENGTH) { modeflag = MODE_DREAM; TCCR0B = _BV(CS00); // nuevo prescaler } break; }
}
// Inicializo IRQ
void irqinit (void)
{ // Valor del Timer scaler TCCR0B |= (_BV(CS02) | _BV(CS00));
// Habilito desbordamiento IRQs TIMSK0 = _BV (TOIE0); sei (); // IRQ on
}
int main(void)
{ uint8_t userflag; /* Inicialización*/ DDRB &= ~_BV(DDB4); // borro bit PORTB |= _BV(BUTTON); // Habilito resistor pull-up DDRB |= _BV(DDB1) | _BV(DDB2); // Configuro salidas //PORTB &= ~(LED); // y las apago // Veo si el pulsador esta presionado en el arranque if(!(PINB & _BV(BUTTON))) userflag = 1; // inicializo IRQ irqinit(); // Enciendo LEDs y // espero antes de comprobar nuevamente while(macropulse < 14) { PORTB |= (LED); } PORTB &= ~(LED); // sigue presionado? Paso a modo inmediato if(!(PINB & _BV(BUTTON)) && userflag) waitstate = WAIT_LENGTH; // “Duermo” el CPU set_sleep_mode (SLEEP_MODE_IDLE); sleep_mode ();
// Bucle infinito while(1) { }
return(0);
}
