Lucid Dream Machine: Cómo lograr un sueño lúcido

Se denominan sueños lúcidos a aquellos sueños en los que uno puede darse cuenta 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.

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 lucido, 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 denominan onironautas.

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 se comienzan a emitir pulsos de luz unas cuatro horas después que te has dormido. Según dice su autor, el brillo de los LEDs a través de los parpados bastan 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, necesitaras 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 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 ohms
1x llave de encendido SPST o SPDT
1x pulsador normalmente
1x batería de litio de 3volt (CR2032, por ejemplo)
1x un porta batería
1x gafas para dormir o similares

El valor de los resistores que van en serie con los diodos LEDs son los que determinarán 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 ohms, 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 lucido, 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.

Hemos colocado aquí el código fuente del microcontrolador AVR, con los comentarios en español, por si quieres saber como funciona o realizar algun cambio. Esta escrito en lenguage 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);
}