Por si ya lo has olvidado, vamos a montar un sistema que detecta la presencia de gente mediante un PIR. Si hay alguien presente enciende unas luces paulatinamente hasta llegar a su máximo de intensidad y después, tras un cierto tiempo sin que se detecte a nadie, las apaga también paulatinamente. Aquí tienes el vídeo otra vez:

Para completar este magnífico artefacto necesitarás montar unos pocos “periféricos” además de la placa con el micro. Veámoslos uno por uno después del salto.

Selector de tiempo

• Un potenciómetro (entre 10KΩ y 1MΩ todo vale).
• Cable plano de 3 conductores (de nuevo, los viejos cables IDE vienen muy bien para esto).
• Una tira de pines macho.

Lo que queremos hacer con esto es conectar las dos patas exteriores del potenciómetro a 0 y 5 V respectivamente. De esta manera el voltaje que obtengamos en la pata central (que está conectada electricamente al cursor del potenciómetro) será proporcional al ángulo que tenga e l cursor en es momento. Esto es, si giramos el cursor todo a la izquierda tendremos 0V en la pata central. Si lo giramos todo a la derecha tendremos 5V. Y en las posiciones intermedias tendremos un valor proporcional al de su posición.

Luego, conectaremos este selector al puerto de sensores y nuestro software se encargará de leer periódicamente el valor del voltaje para determinar cuanto tiempo tiene que esperar sin detectar a nadie antes de ponerse a apagar las luces. De este modo podremos ajustar dicho tiempo en directo como quien cambia el volumen de la tele.

El esquema del circuito es este:

Y este es el aspecto del sensor una vez terminado. Nada espectacular.

Fijate que he quitado el pin que va entre GND y 5V para que el hueco coincida con el agujero que hay “tupido” en el puerto de sensores. En este caso usé pines acodados, pero he descubierto que es más cómodo si usas pines rectos normales.

Sensor de presencia

• Un sensor PIR (Los hay de muchos tipos, nosotros estamos usando éstos).
• Una resistencia de 100KΩ.
• Cable plano de 3 conductores.
• Tira de pines macho.

Para que nos entendamos, los sensores PIR son una especie de cámara de muy baja resolución que sólo puede ver el infrarrojo. Como las personas (y los seres vivos en general) están más calientes que su entorno “brillan” (en el infrarrojo) más que el fondo. Cuando un PIR detecta ese cambio en el brillo en alguna zona de su campo de visión asume que tiene a alguien delante.

El alcance y el ángulo de visión de un PIR varían mucho según el modelo. Lo normal es que el alcance esté entre los 2’5 y los 10 metros, y que el ángulo se encuentre entre los 30º y los 100º.

Los modelos que estoy usando tienen tres pines. Uno va a tierra (GND), otro a 5V para la alimentación (Vdd) y el tercero nos da la salida del sensor (OUT). El voltaje que midamos en este pin será 5 V cuando no hay nadie presente y 0V cuando se detecte a alguien (ojo, ya ves que la salida esta invertida).Por último, aunque no lo pone en la hoja de datos de estos PIRs, parece que es necesario utilizar una resistencia pull-down de 100KΩ entre la salida y tierra para que la señal sea lo bastante limpia.

Dicho lo cual, aquí tienes el esquema del circuito y una fotico con el resultado:

Cable de comunicaciones

• Cable plano de 10 hilos.
• Dos conectores hembra de cable plano de 10 hilos

Este es el tipo de cable que necesitaremos, en general, para conectar nuestros periféricos a la “placa base”. Solo tienes que ponerle los conectores en los extremos. Normalmente la gente usa herramientas especiales para cerrar bien los conectores, pero yo lo he estado haciendo golpeándolos con un mazo de goma y sale bastante bien. Lo único es que tienes que ir poco a poco, por que si un lado del conector se encaja más rápidamente que el otro se pueden partir las pestañas que hacen que se mantenga todo unido. También he ocluido los agujeros que corresponderian a los pines que faltan en los puertos de entrada/salida para que no se pueda colocar el cable incorrectamente.

Distribuidor

• Pines machos dobles.
• Pines hembra acodados.

Pues sí, tener 4 pines de entrada/salida agrupados en un solo conector está muy bien cuando vas a necesitarlos todos a la vez, cuando quieres “hablar” en serie con un dispositivo o controlar un pequeño motor. Pero, ¿qué pasa si solo quieres encender una luz? O mejor: dos luces, separadas entre sí, y controladas cada una por un pin distito del microcontrolador. En estos casos, necesitamos una plaquita que nos permita separar las señales y dirigir cada una a su destino final.

Estas placas presenta en un lado un conector donde enchufaremos el extremo final del cable de comunicaciones y en los otros lados entre 1 y 4 conectores más pequeños hasta donde llevan las 4 señales de datos individuales y el voltaje de alimentación.

En este proyecto vamos a usar solamente una señal, pero aquí tienes tambien el esquema del distribuidor para dos señales que seguro que viene bien en el futuro.

Para que quede un poco más claro puedes ver las fotos de ambos circuitos completados. (Pero no hagas caso del jumper que se ve en el centro del distribuidor de dos señales, resultó que no era muy buena idea).

Amplificador

• Un transistor MOSFET tipo n. (Te cuento los detalles más abajo).
• Una resistencia de 200 Ω.
• Pines acodados machos y hembras.
• Dos bornes de conexión para circuito impreso.

Queremos encender luces, y queremos que sean unas luces que marquen alguna diferencia entre “oscuro” y “luminoso”, pero los puertos de datos de nuestro controlador sólo pueden proporcionar unos 40 mA de corriente por cada pin. Está bien para encender un led, pero no te harán llegar muy lejos en la noche. Además, dan una tensión de salida de 5V y las bombillas que queremos usar son de 12V (como las de los coches).

Necesitamos una manera de amplificar las señales que manda el controlador hasta que sean lo bastante potentes como para encender esas bombillas. Para ello usamos un transistor MOSFET tipo n a modo de interruptor. Los MOSFETs tienen tres patas, drenador (drain), fuente (source) y puerta (gate). La corriente principal (la que encenderá nuestra bombilla) entra por el drenador y sale por la fuente. Cuando la puerta se encuentra conectada a tierra (0V) se dice que el transistor está en corte y no permite pasar corriente entre drenador y fuente. Cuando el voltaje de la puerta supera cierto voltaje umbral (positivo para los tipo n y negativo para los tipo p) el transistor está en saturación y permite que pase gran cantidad de corriente entre drenador y fuente.

Las características más importantes para este tipo de transistores son 3: el voltaje fuente-drenador máximo (VDSs), que es la diferencia de potencial máxima que podemos poner entre fuente y drenador sin que pete todo; la intensidad de drenador máxima (ID), que es la intensidad máxima que puede aceptar el drenador sin quemarse; y el voltaje umbral ( VGS(th)) que, simplificando, sería el voltaje que hay que aplicarle a la puerta para que el transistor comience a conducir.

Queremos encender dos bombillas de 12V y 6 Watios cada una. Eso supone que van a consumir un Amperio entre las 2. Además, queremos controlar el encendido con un pulso de 5 V. Total, que necesitaremos un MOSFET con: VDSs>12V, ID>1A y VGS(th)<5V.

En cualquier tienda de electrónica puedes encontrar cientos, si no miles, de transistores que cumplan estos requisitos por menos de un lerele, pero también puedes encontrarlos entre la chatarra electrónica que tengas por casa. Para esta placa yo he usado un STW13NK80Z que encontré en una fuente de alimentación rota. Con VDSs=800V y ID=12A es como matar moscas a cañonazos, sí, pero al menos el cañón nos salió gratis. Busca componentes que tengan este aspecto y estén atornillados a un disipador. Casi seguro que serán algún tipo de transistor. Solo tienes que googlear el numero de serie que llevan impreso para saber de qué se trata exactamente.

Ahora que ya tienes transistor vamos a montar el circuito. Tanto la señal, como la alimentación llegan por el conector macho y se “reenvían” al conector hembra. De este modo se pueden encadenar varios de estos amplificadores si fuera necesario.

El módulo terminado, con la bombilla al lado tiene este aspecto:

Firmware

Contra todo pronóstico ésta era la última pieza que quedaba por montar. Lo siguiente es hacer un programa que se encargue de “leer” el PIR  y el potenciómetro y de controlar la luz. Puedes copiar el mío de aquí abajo Como ves es muy sencillito y está comentado hasta aburrir. Ya hablamos hace meses de cómo compilarlo y grabarlo en el microcontrolador.

/*
 * Firmware detector de presencia para ATMega88. Lee la salida de un sensor PIR y
 * de un potenciómetro en el puerto C (PC0 y PC3 respectivamente).
 * Enciende una luz conectada a PD5 cuando el PIR detecta movimiento (salida > 128)
*/

// Frecuencia de funcionamiento (para las rutinas de delay).
#define F_CPU 1000000
#define TMULT

#include
#include 

//Funciones para inicializar y leer desde las unidades conversoras analógico-digitales
void initialiceADC(void);
unsigned char readADC(unsigned char channel);

//Funciones para inicializar y emplear PWM
void initialicePWM(void);
void analogOut(char port,unsigned char value);

int main(void)
{
	//Aquí se guarda el estado actual del programa
	unsigned char state=0;
	//El valor guardado en 'out' es el que se usará como salida mediante PWM
	unsigned char out = 0;
	unsigned char ant;
	//Aquí llevaremos una cuenta del tiempo transcurrido desde la última detección
	int timer = 0;

	//Configuramos los pines del puerto D como salida
	DDRD=0xff;

	//Inicializamos PWM y ADC
	initialicePWM();
	initialiceADC();

	//Bucle principal.
	while(1)
	{
		switch(state)
		{
			//Estado 0: Apagado, esperando a detectar algo
			case 0:
				//Cuando se detecta a alguien pasamos a estado 1.
				// La salida para a 10 (muy poco brillo)
				if(readADC(0)>128)
				{
					out=10;
					state = 1;
				}
				else out=0;
				break;
			//Estado 1: Aumentando el brillo
			case 1:
				//Aumentamos el en cada iteración. Como la percepción del
				//brillo es logarítmica tenemos que aumentarlo exponencialmente
				//para que se perciba como un aumento lineal. En concreto
				//multiplicamos el brillo anterior por 1.125
				ant = out;
				out+= out>>3;
				//Si el brillo anterior es mayor que el actual -> overflow
				//Fijamos el brillo en 255 y pasamos al estado 2
				if(ant>out)
				{
					out = 255;
					state = 2;
				}
				break;
			//Estado 2: Brillo máximo hasta que pase un cierto tiempo desde la última detección
			case 2:
				//Si se detecta movimiento reseteamos el temporizador
				if(readADC(0)>128)
					timer =0;
				//si no lo aumentamos
				else
					timer++;

				//El tiempo que debe pasar depende de la posición del cursor de potenciómetro
				//será un valor entre 0 y 255 multiplicado por TMULT (para TMULT = 4 abarca entre
				// 0 y 90 segundos aprox).
				//Cuando timer supera ese valor lo ponemos a 0 y pasamos al estado 3.
				if(timer>(readADC(3)*TMULT))
				{
					timer = 0;
					state = 3;
				}
				break;
			//Estado 3: Disminuyendo el brillo
			case 3:
				//Reducimos el brillo igual que lo aumentamos antes. En lugar de
				//multiplicarlo por 1.125 ahora lo hacemos por 0.875
				if(readADC(0)>128)
					state = 1;
				else
				{
					ant = out;
					out-= out>>3;
					//Si ant=out es que out ya era tan pequeño que al redondear tras la
					//división se queda igual. Fijamos out a 0 y volvemos a la espera
					//en el estado 0
					if(ant<=out)
					{
						out = 0;
						state = 0;
					}
				}
				break;

		}
		//En cada iteración actualizamos el valor de la salida a 'out'
		analogOut(0,out);
		//y esperamos un poco antes del siguiente paso
		_delay_ms(100);
	}
}

void initialiceADC(void)
{
	DIDR0=0x3F; //Deshabilita la entrada digital a traves de los pines de ADC

	//REFS(0,1) pone Vcc como voltaje de referencia
	//y ADLAR(1) justifica el valor leido a la izquierda para que solo tengamos que leer ADCH
	ADMUX= _BV(REFS0)|_BV(ADLAR);
	//ADEN habilita el uso de ADC y ADPS(0,1,1) pone el preescale del temporizador ADC a 8
	ADCSRA = _BV(ADEN)|_BV(ADPS1)|_BV(ADPS0);

}

unsigned char readADC(unsigned char channel)
{
	ADMUX= (ADMUX & 0xF0) | channel;
	//Poniendo ADSC a 1 comienza la conversión
	ADCSRA|=_BV(ADSC);
	//Sabemos que ha teminado cuando ADSC vuelve a valer 0
	while(ADCSRA & _BV(ADSC));
	//El resultado está en ADCH
	return ADCH;
}

void initialicePWM()
{
	//Configuramos PD5 y PD6 como salidas
	DDRD |= _BV(PD5)| _BV(PD6);
  	//WGM0(0,1,1) selecciona el modo 'fast PWM'. COM0A(1,0) y COM2B(1,0)
  	//proporciona PWM no invertido para las salidas A y B
       TCCR0A = _BV(WGM01)|_BV(WGM00) | _BV(COM0A1)|_BV(COM0B1);
       //CS0(0,1,0)configura el preescaler de timer0 a 8
       TCCR0B = _BV(CS01);
}

void analogOut(char port, unsigned char value)
{
	//Si 'port' es 1 usamos la salida B. Si es 0 la A
	if(port & 1)
		OCR0B = value;
	else
		OCR0A = value;
}

Y dicho lo cual solo queda ensamblarlo todo. Si ha ido todo bien no deberías poder conectar nada incorrectamente, pero asegúrate antes de enchufarlo todo a la corriente por primera vez. Aquí tienes un par de fotos para que puedas fijarte en donde va conectada cada cosa.

Bueno, pues ya tienes tu propio detector de movimiento. Pero tendrás que quedarte muy muy quieto para ver cómo se apaga la luz.

¿Qué?

No le he puesto nombre aún

¿Por qué esto?

Arduino Diecimila

¿Por qué así?

1. El puerto de programación: Nos permite conectar la placa al ordenador, a través del puerto paralelo, para programarlo e intercambiar datos.
   

   Puerto de programación

2. El conector de alimentación: Se trata de un conector hembra estándar de 2’5 mm. Es un conector muy común entre los transformadores domésticos (nosotros hemos encontrado muchos en las fuentes de alimentación de los modems y routers) y como la placa lleva su propio 7805 nos permite usar casi cualquier fuente de tensión de entre 7 y 18 V.
   

   Conector de alimentación

3. Puerto de sensores: Porque todo robot asesino que se precie necesita una buena batería de sensores para localizar a sus víctimas. Este puerto ofrece conexiones a los pines 0 a 3 del puerto C del microcontrolador (los que tienen el conversor analógico/digital) para poder medir el estado de sensores tanto analógicos como digitales. Como además los sensores suelen estar separados entre sí y suelen necesitar alimentación cada columna del puerto incluye, además del pin de entrada, un contacto a tierra y otro a 5 V. De este modo, con un único cable (con 3 conductores) entre la placa y el sensor podemos transmitir tanto la energía necesaria para que funcione el sensor como los datos proporcionados por éste.
   

   Puerto de sensores

4. Puertos de entrada y salida digital: Así que necesitas comunicarte con algún periférico. Para que tu controlador pueda hablar con un chip de memoria o un display LCD necesitarás usar varios pines a la vez. Estos dos puertos están hechos con 2 filas de 5 pines colocados de tal manera que puedes enchufar un conector de cable plano de 10 hilos en cada uno o un conector de 26 hilos en los dos a la vez. Entre los dos dan acceso a los pines del puerto D (uno a los pines 0 a 3, el otro a los pines 4 a 7). Así puedes acceder a todo el puerto D a la vez con un conector y un cable de 26 hilos (aunque se “desperdician” algunos cables) o conectar dos perifericos independientes que solo necesiten 4 pines. Cada uno de estos puertos ofrece además dos pines conectados a tierra, dos pines conectados directamente a la fuente de tensión (para poder alimentar directamente un motor o una luz, por ejemplo) y otro pin conectado a la tensión regulada de 5 V (que es el voltaje de alimentación típico de la mayoría de los componentes electrónicos).
   

   Puerto I/O digital

Cómo

1. Un trozo de placa perforada (perfboard).
2. Un ATMega88 (Los ATMega48 y ATmega168 también valen y sólo se diferencian en la cantidad de memoria de que disponen).
3. Un zócalo de 2×14 patas (para sujetar el microcontrolador).
4. Un 7805 (proporciona la tensión regulada de 5V.
5. Dos condensadores de 10 nF (uno es para “suavizar” un poco la tensión de alimentación y efiltrar otro para filtrar ruidos en las entradas de los conversores analógico/digitales).
6. Un conector de alimentación de 2.5mm.
7. Una pareja de tiras de pines dobles (macho y hembra).
8. Una tira de pines acodados hembra.
9. Algunos trozos de cable rígido.

Esquema eléctrico

Cara A

Cara B

Antes de ponerte a soldar recuerda que tienes que agrandar los agujeros para el conector de alimentación. Mejor ahora que no puedes dañar nada en el proceso. Empieza a soldar por los componentes que menos sobresalgan sobre la placa. Los cables, luego el zócalo y el puerto de programación, el resto de los puertos, los condensadores, el 7805 y, por último, el conector de alimentación.

El cable

• Un trocito de placa perforada.
• Un conector de puerto paralelo macho (DB-25).
• 5 resistencias (entre 100 Ω y 1KΩ).
• Cable plano de 5 conductores (yo uso el cable de los discos duros IDE y de las disqueteras, partiéndolo en tiras de la anchura que me interesa).
• Una tira de pines acodados macho.

Disclamer

Valor de los pines del puerto. Extraido de CodeProject

Además tenemos que Data es de entrada/salida, Control es sólo de salida y Status sólo de entrada. Y que en un determinado pin 0V representan un 0 lógico y 5V un 1 lógico, salvo en los pines que están invertidos (Y este puede ser un buen momento para repasar el primer artículo).

Vimos también que para sacar un byte a través de un puerto hay que usar la función:

outb(Byte,Puerto);

donde Byte es el byte de datos que queremos mostrar y Puerto es el numero del puerto que queremos usar y que en la mayoría de los casos es 0×378 para el puerto de datos, 0×379 para el puerto de status y 0×380 para el puerto de control.

Pues bien, para la entrada de datos tenemos una función similar:

inb(Puerto);

que devuelve un byte de datos leidos a traves de Puerto. Por ejemplo, para leer desde el puerto de status y guardarlo en la variable input pondríamos:

short int input = inb(0x379);

Y eso es todo amigos, pero antes de ponernos con un programa de ejemplo deja que aclare una cosilla sobre circuitos eléctricos.

Breve anotación sobre los circuitos eléctricos

En un circuito eléctrico, un cable que no está conectado a nada no está a 0V. Vale, puede que para ti esto sea una perogrullada, pero si no estas familiarizado con la electricidad, lo más inmediato es pensar que un cable que no esta conectado, por el que no pasa electricidad, no tiene un voltaje, o sea que está a 0V.

Pero no es tan sencillo. Y por lo que he podido comprobar mucha gente tiene esa creencia, que por otra parte causa muchos problemas a la hora de intentar leer datos digitales.

Te pondré un ejemplo: fíjate en el esquema de aquí abajo a la izquierda. Uno podría pensar en usar un montaje como éste para detectar la pulsación de un boton. Si Entrada es uno de los pines del puerto de estatus podemos usar inb(0×379) para ver el estado de ese pin.

Cuando pulsamos en interruptor el circuito se cierra,el pin de entrada está a 5V y leemos un 1 en ese bit. Cuando se suelta el interruptor el circuito se abre de nuevo y el pin de entrada queda “al aire”, con lo que debe de estar a 0V y leemos un 0 en su bit, ¿no? Pues más bien no.

En primer lugar desconocemos cómo es el circuito detrás de ese pin. Dentro de tu ordenador el mismo circuito que se encarga de la lectura del pin podría estar induciendo ahí un cierto voltaje desconocido para nosotros. Podría ser 0, podría ser 5, podría ser cualquier valor entre 0 y 5. You never know.

Eso ya es bastante malo. Pero es que además la configuración del circuito podría hacer que éste actuase como un diminuto condensador y cualquier carga igualmente diminuta que quede atrapada en él produciría también un voltaje desconocido para nosotros. Incluso puede darse el caso de que el cable que estemos usando para la entrada actúe como una antena de radio y nuestra entrada se vea afectada por todo tipo de interferencias.

Para que nos entendamos, y reformulando la primera sentencia para un caso más concreto: Un pin de entrada que no está conectado a nada no está a 0V, tendrá un voltaje arbitrario y desconocido para nosotros.

¿Y cómo salimos de ésta pues? No te dejes los pines al aire. Por ejemplo: En lugar del interruptor simple de antes podemos usar un selector como el del siguiente esquema:

En este caso, cuando el selector está arriba tenemos la entrada conectada a los 5V (1 lógico) y cuando está abajo la entrada pasa inmediatamente a estar a 0V (0 lógico). Aquí cada estado del selector está asociado inequívocamente a un valor del bit leído. Puedes encontrar este tipo de selectores bajo los botones del ratón de tu ordenador. De los tres pines que tienen, el que se encuentra bajo el pulsador está normalmente conectado al del otro extremo y cuando se presiona el pulsador pasa a estar conectado al del centro.

Ejemplo de conexión de un selector. En esta imagen y en las siguientes el cable azul está conectado a tierra (0V) y el naranja a 5V.

Otra forma de mantener la entrada siempre a un voltaje conocido es usar una resistencia pull-up o pull-down. A continuación tienes el esquema del montaje de una resistencia pull-down:

Se emplea una resistencia de valor intermedio. Lo más habitual es que sea de 1 o 10 KΩ. Cuando el interruptor está cerrado, la resistencia que ofrece la rama del circuito que va a los 5 V es mucho menor que la que va hasta los 0V así que el voltaje en el nodo donde confluyen las tres ramas del circuito es prácticamente 5V. Lo bueno es que aquí, cuando el interruptor se abre, el pin de entrada no queda aislado, sino que sigue conectado a tierra a través de la resistencia. Cualquier carga que hubiera quedado atrapada en el circuito se descarga rápidamente a través de la resistencia y la entrada se pone a 0V.

Una resistencia pull-up funciona igual, pero se conecta a los 5V como en este esquema:

En este caso con interruptor cerrado la rama de tierra tiene mucha menos resistencia que la de 5V y el voltaje en el nodo es de (prácticamente) 0V. Al abrirse el interruptor, la resistencia mantiene la entrada conectada a los 5V y el voltaje de entrada sube hasta ese valor.

Aquí abajo puedes ver como sería la entrada con una resistencia pull-dow (izquierda)  y otra pull-up (derecha).

De vuelta al software

//Este programa monitoriza el valor estado de 2 pulsadores conectados
//a las lineas de STATUS y muestra por pantalla si se ha pulsado alguno de ellos
 
#include
#include 
 
//sys/io.h es donde estan definidas las funciones ioperm() y inb()
#include 
 
// Esta es la direccion mas frecuente para el puerto paralelo
#define DATAPORT 0x378
//Y esta es la direccion de las lineas de Status
#define STATUSPORT DATAPORT+1
 
#define TIEMPOCONPULSACION 300000
#define TIEMPOSINPULSACION 10000
 
//Mascaras para los pines 3 y 4 del puerto de Status
#define BOTON1 8
#define BOTON2 16
 
int main()
{
  //Obtenemos permiso de acceso para la direccion de DATAPORT y
  //las 2 siguientes
  if (ioperm(DATAPORT, 3, 1)) {perror("ioperm"); return 1;}
 
  //Entramos en el bucle principal del programa
  while(1)
  {
	//input va a guardar el valor leido desde el puerto
    short int input=0;
    //pulsacion nos va a decir que boton se ha pulsado
    short int pulsacion = 0;
 
 	//Leemos el byte de las lineas de Status y lo guardamos en input
 	input=inb(STATUSPORT);
 
 	//Si input tiene el bit BOTON1 a cero es que se ha pulsado el boton correspondiente
 	if((input & BOTON1) ==0)
 		//Ponemos pulsacion a 1 para indicarlo y sacamos un mensaje por pantalla
 		pulsacion=1;
 	//Si tiene a cero el bit BOTON2 es que se ha pulsado el otro boton
 	else if((input & BOTON2) ==0)
 		pulsacion=2;
 
	//Si pulsacion !=0 es que se ha pulsado algun boton.
	//Esperamos TIEMPOCONPULSACION microsegundos para no inundar la pantalla de texto
	if(pulsacion)
	{
		printf("Pulsando boton %d\n",pulsacion);
 		fflush(stdout);
		usleep(TIEMPOCONPULSACION);
	}
	//En caso contrario solo esperamos TIEMPOSINPULSACION microsegundos
	else usleep(TIEMPOSINPULSACION);
  }
  //Antes de terminar el programa dejamos los permisos de acceso
  //a los puertos como estaban
  if (ioperm(DATAPORT, 3, 0)) {perror("ioperm"); return 1;}
 
  //El programa termina sin errores
  return 0;
}

outb(0x10,0x380);

short int input = inb(0x378);   

Otra vuelta de tuerca

//Este programa monitoriza el valor estado de 2 pulsadores conectados
//a las lineas de STATUS y cambia la posicion del led que esta iluminado
 
#include
#include 
 
#include 
 
//Direccion del puerto paralelo
#define DATAPORT 0x378
#define STATUSPORT DATAPORT+1
 
#define TIEMPOCONPULSACION 300000
#define TIEMPOSINPULSACION 10000
 
#define BOTON1 8
#define BOTON2 16
 
int main()
{
  //Obtenemos permiso de acceso para DATAPORT
  if (ioperm(DATAPORT, 3, 1)) {perror("ioperm"); return 1;}
 
  //light va  aguardar el estado de la salida del puerto.
  //Lo hacemos igual a 00000001 en binario
  unsigned short int light=1;
  //y lo sacamos por el puerto paralelo para que se encienda el primer led
  outb(light, DATAPORT);
 
  //Bucle principal
  while(1)
  {
    short int input=0;
    short int pulsacion = 0;
 
 	input=inb(STATUSPORT);
 
 	if((input & BOTON1) ==0)
 		//Se ha pulsado el boton 1
 		pulsacion=1;
 	else if((input & BOTON2) ==0)
 		//Se ha pulsado el boton 2
 		pulsacion=2;
 
	if(pulsacion==1)
	{
		//Si light es (00000001)b lo convertimos en (10000000)b
		if(light==1)
			light=128;
		//Si no, desplazamos el 1 un lugar a la derecha
		else
			light>>=1;
 
		//Sacamos el nuevo valor por el puerto
		outb(light, DATAPORT);
		usleep(TIEMPOCONPULSACION);
	}
	else if(pulsacion==2)
	{
		//Si light es (10000000)b lo convertimos en (00000001)b
		if(light==128)
			light=1;
		//Si no, desplazamos el 1 un lugar a la izquierda
		else
			light<<=1;
 
		//Sacamos el nuevo valor por el puerto
		outb(light, DATAPORT);
		usleep(TIEMPOCONPULSACION);
	}
	else usleep(TIEMPOSINPULSACION);
  }
 
  //Restauramos los permisos de acceso al puerto
  if (ioperm(DATAPORT, 3, 0)) {perror("ioperm"); return 1;}
 
  //El programa termina sin errores
  return 0;
}

Pincha para ampliar

Los osciladores (discos duros)

Potenciometro listo para su colocación con su cable y su conector de 3 pines hembra

El láser

La fuente de alimentación del láser también la tenemos hecha de antes. Aunque también en este caso he cambiado alguna cosilla. Como solo vamos a usar uno de los canales le he quitado uno de los potenciómetros y le he puesto solo dos bornes de salida (en lugar de los tres que tiene la original). Una vez tienes la fuente, lo habitual en este tipo de punteros de baratillo es que tengas que conectar el polo positivo a la carcasa del puntero y el negativo el muelle que llevan en el compartimento de las pilas. Si no alcanzas bien ese muelle puedes hacer como yo y serrar el puntero para dejarlo a la vista.

Y como ves, después de conectarlo todo he pegado directamente el láser a la fuente para ahorrar espacio.

La caja

Al final te quedan todos estos cables

Afortunadamente, desde fuera queda mucho mejor. Si quieres, este es el momento de recortar los palotes de los potenciómetros, que sobresalen demasiado.

Ya solo tienes que conectarlo al típico transformador universal y podrás ver tu música favorita. Y ahora, además, puedes hacerlo en cualquier parte.

Los tres teclitos

Un teclito diseccionado

¿Está claro, no?

Cuestiones previas

• En este caso, asumiremos que el servidor está corriendo sobre un Debian GNU/Linux o una distribución basada en Debian, y que en los clientes queremos instalar Debian Lenny.
• Asumiremos también que estamos trabajando con una red local del tipo 192.168.1.0, que son la mayoría de ellas.
• Por último decir, que la instalación, configuración y demás operaciones las haremos desde una consola con permisos de usuario administrador. En las líneas de este pequeño manual indicamos esto con la notación root@server:~#, antes de cada orden que hay que ejecutar como administrador o root.

Requisitos y configuración del equipo cliente

Requisitos y configuración del equipo servidor

Servidor DHCP

root@server:~# apt-get install dnsmasq

dhcp-range=192.168.1.223,192.168.1.254,12h dhcp-no-override dhcp-boot=pxelinux.0 enable-tftp tftp-root=/var/lib/tftpboot

root@server:~# /etc/init.d/dnsmasq restart

Servidor TFTP

root@server:~# apt-get install tftpd-hpa

RUN_DAEMON="yes" OPTIONS="-l -s /var/lib/tftpboot"

root@server:~# /etc/init.d/tftp-hpa start

Servidor PXE

root@server:~# cd /var/lib/tftpboot root@server:/var/lib/tftpboot# wget http://ftp.es.debian.org/debian/dists/lenny/main/installer-i386/current/images/netboot/netboot.tar.gz root@server:/var/lib/tftpboot# tar -zxvf netboot.tar.gz

Más sobre el tema

Materiales

• Un recorte de placa perforada sobre la que soldar los componentes.
• Un 7805.
• Un interruptor.
• Un led.
• Una resistencia de 480 Ohmnios.
• Un portapilas para pilas de 9V.
• Dos pines.

Construcción

Como ves, nada del otro mundo. Sólo tienes que introducir la dirección del servidor al que quieres conectarte (el puerto por defecto es el 22), el tipo de sistema al que vas a conectarte, la velocidad de la conexión y el tamaño que quieres que tenga tu escritorio remoto. Bastante fácil.

Por cierto, el NX de NoMachine para linux es gratuito, pero si te va la marcha existe una versión totalmente libre llamada FreeNX, aunque resulta algo más complicada de instalar.

Y eso es todo. Nada demasiado expectacular, pero creo que este programa puede suponer una muy buena herramienta contra la obsolescencia ya que nos permite rescatar las máquinas más limitadas para usarlas como terminales de conexión a nuestro nuevo y gordo servidor, tal como apuntó hace tiempo erseco en uno de sus comentarios.

Cubo luminoso.

Como ves, se trata de un cubo hecho con papel. Papel vegetal, en concreto. En cada una de sus seis posiciones el cubo se ilumina con un color distinto (salvo en una de ellas, en la que el cubo se apaga). Por cierto, la luz que se ve rosa/naranja en el vídeo, en realidad es amarilla. Curioso efecto de la cámara.

Este simpático elemento decorativo consta de 2 sensores de inclinación y seis leds, y se puede construir en un par de horas. Todo lo que necesitas (aparte de una cierta determinación) es un poco de cable unifilar (solid), otro poco de cable de cobre multifilar (stranded), una hoja A-2 de papel vegetal,  dos monedas de diez céntimos de euro y seis mecheros con luz de los del todo a cien (dos blancos y los otros, uno de cada color).

Los mecheros los queremos por sus leds y por sus baterías. También puedes comprar este material en una tienda de electrónica, pero un led ultrabrillante, un portapilas y tres pilas de botón probablemente te cuesten más de los 90 céntimos que cuesta el mechero. Y no te permiten encender fuego.

Las monedas las vamos a usar como interruptor (ya veras cómo).  Puedes usar cualquier moneda, que yo sepa, pero entonces tendras usar tus propias medidas. Un consejo: En general, cuanto más pesada sea la moneda mejor funcionará el asunto.

El circuito  a usar es muy simple. Imagina el típico circuito con un interruptor y una luz, como éste:

Lo que vamos a hacer, como hemos dicho antes, es usar la moneda a modo de interruptor ¿Cómo? Fácil. Como la moneda es metálica (y por ende conductora de la electricidad) la vamos a colocar de manera que cierre el circuito cuando está en determinada posición. Algo tal que así:

Bueno, esta es la base, pero así solo podemos encender o apagar una luz. Ahora tenemos que añadir otras dos ramas al circuito para poder controlar tres leds. Además así podemos aprovechar los contactos extra para mantener a la moneda “enjaulada”. El circuito final nos queda así:

Y el comportamiento, según hacia donde lo inclinemos sería parecido a esto:

Y dicho esto pongámonos manos a la obra. Empecemos formando la “jaula” para la moneda. Parte ocho trozos como de 1 cm de largo de cable unifilar y pélalos. Estos van a hacer de barrotes. Ahora suéldalos a un trozo de placa perforada como en la foto:

Deja 5 agujeros libres entre barrotes de un mismo lado (1 en diagonal entre barrotes en lados perpendiculares).

Detalle de un rulillo de cobre antes de separarlo del resto del cable y los seis rulillos ya preparados.

Vamos a usar las pelotillas de cobre para dos cosas:  Como separadores, para apoyar la pieza que hará de techo de la jaula y que quede suficiente espacio para que la moneda se mueva libremente; como contactos, los vamos a soldar alrededor de los barrotes para que hagan de puntos de contacto de la moneda. De esta manera aumentamos la superficie y la elasticidad de los contactos, lo que hará que el circuito responda mucho mejor a pequeñas sacudidas y vibraciones.

Así que, venga: pincha cada ovillo de cobre en un barrote y aplícale una gotica de estaño. Ah, sí, hay que dejar los dos barrotes de uno de los lados libres. Estos serán los que correspondan a la posición de apagado.

La moneda y los topes en su sitio, antes de poner la tapa.

Como ves ya puedes meter la moneda, pero antes hay que limpiarla bien. La mugre y el óxido que haya podido acumular en su deambular de mano en mano van a impedir que haga buen contacto. Te recomiendo lijar bien el canto y limpiarlo con un poco de alcohol. Cuando tengas la moneda limpia y en su sitio pon la tapa (que será simplemente otro trozo de placa perforada) y suéldala.

Suelda la tapa con la metalización hacia afuera

Llegados a este punto la moneda debería poder moverse libremente dentro de la jaula.  Sin salirse, claro. Si todo ha ido bien, ya puedes ponerte con el resto del circuito. Simplemente sigue el esquema que te puse más arriba. Solo una cosa: Asegurate de que el led conectado al pin 3 sea uno de los blancos. Los otros leds que sean de colores distintos.

Si compraste los mecheros tienes los leds y los portapilas necerarios ahí dentro. Para sacarlos desatornilla el culo de los mecheros y presiona el boton de encendido mientras tiras del led. Deberias encontrarte con algo así:

Esto es lo que te dan por 90 céntimos.

Ahora corta el alambre que sujeta el led al portapilas como a 3 mm de la base del led. Con esto ya puedes usar el led en el circuito (pero ojo con la polaridad). Para usar el portapilas primero tendrás que soldar un cable a su contacto plano.

Vamos a usar led y portapilas por separado.

Bueno, ahora deberías tener un bonito sensor de inclinación de 4 posiciones entre las manos. Debería encenderse un led distinto según sobre qué canto lo apoyes (salvo en uno, que es la posición de apagado). Tambien deberían apagarse todos los leds si lo dejas plano sobre la mesa.

¿Funciona? No fue tan difícil, ¿verdad? Pues hay que hacer otro. Igual que este. Lo mismito, pero con leds de otros colores (salvo el blanco que se repite, y en la misma posición).

Con esto terminamos con el soldador. Sólo te queda hacer un poco de papiroflexia. Vamos a usar unos módulos de Sonobe para hacer el cubo. Los módulos de Sonobe son unas construcciones de papel con forma de paralelepípedo que, combinados en distintas cantidades permiten hacer todo tipo de figuras geométricas. Desde tetraedros, con 3 módulos a locuras de 120 módulos.

Por suerte nosotros vamos a hacer un cubo, así que solo necesitaremos hacer seis módulos. Para ello puedes leer las instrucciones aquí o puedes ver el siguiente video (recuerda que tienes que usar papel vegetal):

Antes de ensamblar los módulos para formar el cubo coge dos de ellos y pégale un sensor a cada uno en la parte de atrás (la que es lisa)  con un poco de cinta de doble cara. Uno de los sensores pégalo con el portapilas apuntando hacia una de las “puntas” del módulo y el otro girado 90 grados.

El segundo sensor no está puesto todavía pero debería quedar con el portapilas a la derecha.

Y ya sólo te queda montar el cubo. Puedes ver cómo hacerlo aquí. Como pequeña complicación tienes que conseguir que los sensores queden uno al lado del otro. Los dos con los portapilas apuntando hacia “abajo” como en la foto. Fijate tambien que hemos metido un trozo de papel en la diagonal del cubo que separa ambos sensores. Este papel sirve para difundir la luz que sale de los leds y que el cubo se ilumine más uniformemente.

Una vez montado todo debería tener esta pinta.

Y hasta aquí. Pon el último módulo y sorprende a los colegas. Y recuerda que, aúnque acabas de construir un objeto terriblemente chachi en si mismo, lo mejor de todo esto es que de paso ya sabes como construir sensores de inclinación para tu ejército de robocs.

El puerto paralelo según Wikipedia

Pero empecemos por el principio. Para ir cogiéndole el tranquillo a esto te propongo empezar con unos sencillos juegos de luces como estos:

Controlando 8 leds con el puerto paralelo on Vimeo. Aprenderemos para qué sirven los distintos pines del puerto paralelo y cómo sacar datos a traves de ellos (leer datos es ligeramente más complicado y lo dejaremos para futuras entregas) . Todo ello en un estupendo entorno linux, pero si tienes Windows puedes ver cómo hacer esto mismo aquí. Si tienes un Mac…  Bueno, no creo que los Mac sigan montando de éstos. No son lo bastante bonitos, supongo.

Los Puertos

Valor de los pines del puerto. Extraído de CodeProject

El puerto de control (CONTROL)  es sólo de salida y se corresponde con los pines C0 a C3, con lo que en principio nos permite trasmitir valores entre 0 y 16. En un principio este puerto se utilizaba para pasarle comandos inmediatos a la impresora como el salto de línea o el reset y  los pines conservan los nombres que se les dieron en esa época. Y por razones históricas tambien, C0, C1 y C3 están invertidos, lo que quiere decir que invierten la salida y, al contrario que los pines normales, representan el 0 con 5 voltios y el 1 con 0 voltios. Por ejemplo, el 6 es 0110 en binario, pero como los bits 0, 1 y 3 están invertidos tendríamos C3, C2 y C0 a 5 voltios y C1 a 0.

Por último tenemos el puerto de estado (STATUS). Se usaba originalmente para recibir el estado de la impresora, también ha heredado los nombres de los pines de aquella época y también presenta algún pin invertido. Es un puerto sólo de entrada, así que no lo vamos a usar por el momento. Pero vete familiarizándote con él.

¿Me sigues, no? ¿No? bueno, es un poco confuso así contado,  pero espero que esta tabla te aclare un poco las cosas.

Signal	BIT	Modo	Direction
-Strobe	C0	Invertido	Salida
-Auto Feed	C1	Invertido	Salida
-Initialize	C2	Normal	Salida
-Select	C3	Invertido	Salida
-Error	S3	Normal	Entrada
+Select In	S4	Normal	Entrada
+Paper End	S5	Normal	Entrada
-Acknowledge	S6	Normal	Entrada
+Busy	S7	Invertido	Entrada

¿Y el resto de los pines? ¿Los que están en verde en el esquema? Pues están conectados a tierra y nos van a dar el voltaje de referencia de 0 voltios

Enchufando cosas.

Bueno, ya sabemos lo que puede hacer cada agujerete, pero ¿cómo enchufamos ahí nuestros inventos?

De momento, y como todavía estamos hablando de aprender a manejar todo esto y de experimentar, te recomiendo que construyas un adaptador para placa de pruebas (protoboard) como éste:

Sólo tienes que pinchar el adaptador a la placa de pruebas para poder acceder a los pines del puerto paralelo directamente desde tus prototipos, lo que va a facilitar muchísimo la experimentación. Y aparte del cable paralelo (que seguro que tienes por ahí de alguna antigua impresora), sólo necesitas un trozo de placa perforada, un conector DB-25 macho y cable unifilar de varios colores (el de pinchar en la protoboard).

Lo que vamos a hacer es sacar un cable de cada pin (salvo de los pines conectados a tierra) y ordenar los extremos en línea, usando un color en cada tipo de puerto para distinguirlos fácilmente.

En rojo el puerto de control, en amarillo el de datos y en verde el de estado. Tambíen se ven, en negro, los dos cables conectados a tierra.

Tienes que dejar como medio cm de cable pelado en dicho extremo antes de soldarlo para que sobresalga por debajo de la placa y se pueda pinchar fácilmente en la protoboard (Posiblemente tendrás que enderezar las puntas un poco para que encajen bien).

Detalle de los extremos de los cables por debajo de la placa.

Un último consejo: Suelda todos lo pines conectados a tierra entre sí y a la placa perforada. Luego conéctales un par de cables, pero no pongas los extremos a la misma altura que los otros. Déjalos más cerca del conector, de manera que cuando pinches el adaptador a tu protoboard los cables de tierra se conecten a las tiras largas verticales mientras el resto de los cables se conecta a las cortas horizontales.

Los pines de tierra estan soldados a los dos cables que sobresalen cerca del centro de la placa. (Haz click en la imagen para verla ampliada).

Nuestro primer experimento.

Los cuadrados con el 470 escrito representan resistencias de 470 ohmnios. Extraído de CodeProject.

Las resistencias que aparecen en el esquema sirven para limitar la corriente que pasará por cada led. Aunque en general son imprescindibles porque, si no, se queman los leds, resulta que cada pin del puerto paralelo sólo puede suministrar 40mA como máximo. Una corriente suficientemente baja para que la aguanten la mayoría de los leds.

Si has usado el adaptador que hicimos antes y has pasado de las resistencias en montaje debería tener esta pinta:

El cable negro largo conecta los leds a tierra cerrando el circuito.

Con esto ya podemos ponernos a programar. Hasta aquí todo lo que te he contado es válido para cualquier sistema operativo. A partir de este momento nos centraremos en Linux, pero te recuerdo que puedes ver cómo hacer esto mismo en un  ordenador con Windows aquí.

En concreto vamos a programar en C. ¿Por qué C? Porque es el lenguaje de programación estandar en Linux y digamos que está muy integrado con el sistema operativo. Nuestro primer programa va a ser muy sencillo, simplemente nos irá pidiendo números por consola y los mostrará en binario a través de los leds. Pero vete echándole un vistazo al código ya que estamos:

#include <stdio.h>
#include <unistd.h>
//asm/io.h es donde están definidas las funciones ioperm() y outb()
#include <asm/io.h>
 
/* Esta es la direccion más frecuente para el puerto paralelo*/
#define DATAPORT 0x378
 
int main()
{
  //Obtenemos permiso de acceso para la direccion de DATAPORT y
  //las 2 siguientes
  if (ioperm(DATAPORT, 3, 1)) {perror("ioperm"); return 1;}
 
  //Entramos en un bucle infinito
  while(1)
  {
    int input;
 
    //Le pedimos al usuario que introduzca un número
    printf("Introduce un número entre 0 y 255 (-1 para salir)\n");
    //Leemos el valor introducido y lo guardamos en "input"
    scanf("%d", &amp;input);
    //Si "input" vale "-1" salimos del bucle
    if(input==-1) break;
    //Si "input" no está entre "0" y "255" (y no era "-1" no nos
    //interesa, así que volvemos directamente al comienzo del bucle
    if(input < 0 || input > 255) continue;
 
    //Si hemos llegado hasta aqui es que "input" vale entre "0" y
    //"255" y podemos sacarlo por el puerto paralelo
    outb(input, DATAPORT);
  }
 
  //Antes de terminar el programa dejamos los permisos de acceso
  //a los puertos como estaban
  if (ioperm(DATAPORT, 3, 0)) {perror("ioperm"); return 1;}
 
  //El programa termina sin errores
  return 0;
}

Para compilar un programa en C como éste, guárdalo en un archivo de texto cuyo nombre termine en “.c” como “parporttest.c” y compílalo mediante gcc (gcc es el compilador de C que viene por defecto con casi todas las distros de Linux, probablemente ya lo tengas instalado aunque no lo sepas) escribiendo “gcc Wall parporttest.c -o parportest” en la consola. Esto generará un fichero ejecutable que se llama “parportest” y que podrás ejecutar cuando quieras desde consola escribiendo “./parportest”.

Pero volvamos al código. Nos interesan dos funciones, sobre todo:

ioperm();

outb();

La primera función  modifica los permisos de acceso de los puertos. Recibe tres enteros. El primero le indica la dirección del primer puerto cuyos permisos queremos modificar, el segundo es el número de puertos y el tercero debe ser “1″ para conceder el permiso y “0″ para quitarlo. De esta manera, para tener permiso de acceso al puerto de datos y a los dos siguientes (que son STATUS y CONTROL) ponemos:

ioperm(DATAPORT, 3, 1);

y, al contrario,  para dejarlo todo como estaba al final del programa (quitando los permisos) ponemos:

ioperm(DATAPORT, 3, 0);

#define DATAPORT 0x378

outb(input, DATAPORT);

outb(input, DATAPORT+2);

Salida del puerto de datos para 13 (00001101 en binario) y 167 (10100111 en binario)

Prueba unos cuantos números y observa el comportamiento de los leds. Cuando te canses puedes intentar modificar el programa y las conexiones para usar el puerto de control  en lugar de el de datos. No debería ser muy difícil con lo que ya sabes, y así practicas.

Salida del puerto de control para 0 (0000 en binario) y 13 (1101 en binario).

¿Ves lo que te decía de los pines invertidos?

Deberes

Y para terminar (que ya va tocando) aquí te dejo el código del programa con el que hice el video del principio. Tampoco debería darte muchos problemas a estas alturas.

#include <stdio.h>
#include <unistd.h>
#include <asm/io.h>
 
// Esta es la direccion más frecuente para el puerto paralelo
#define DATAPORT 0x378 /* lpt1 */
 
//Duración de cada paso en microsegundos
#define DELAY 150000
 
//Numero de veces que se repite cada secuencia
#define REPEAT 4
 
void Blink();
void Alternate();
void ZigZag();
 
int main()
{
  //Obtenemos permiso de acceso para la direccion de DATAPORT y
  //las 2 siguientes
  if (ioperm(DATAPORT, 3, 1)) {perror("ioperm"); return 1;}
 
  //mode indique que secuencia es la que se esta ejecutando
  int mode=0;
  while(1)
  {
    int i;
    for(i = 0 ; i < REPEAT; i++)
    {
      int reset=0;
      //Comprueba el valor de mode
      switch (mode)
      {
        //Si vale 0 toca parpadeo
        case 0:
          Blink();
          break;
        //Si vale 1 toca alternar pares e impares
        case 1:
          Alternate();
          break;
        //Si vale 2 toca hacer un ZigZag
        case 2:
          ZigZag();
          break;
        //Si vale otra cosa, vovemos a empezar. Para ello
        // ponemos mode a -1
        default:
          mode=-1;
      }
    }
    //Despues de repetir REPEAT veces una secuencia pasamos 
    //a la siguiente sumandole 1 a mode
    mode++;
  }
 
  //Volvemos a cerrar los puertos
  if (ioperm(DATAPORT, 3, 0)) {perror("ioperm"); return 1;}
 
  return 0;
}
 
//Esta función hace parpadear los leds.
void Blink()
{
  //Ponemos todos los led a 1
  outb(255,DATAPORT);
  //Y esperamos 2*DELAY microsegundos
  usleep(2*DELAY);
 
  //Luego ponemos todos los leds a 0
  outb(0,DATAPORT);
  //Y volvemos a esperar
  usleep(2*DELAY);
}
//Esta función enciende alternativamente los leds pares y los impares
void Alternate()
{
  int i;
  //repetimos cuatro veces
  for(i=0;i<4;i++)
  {
    int output = 85;
 
    //Primero ponemos 85 que es 01010101 en binario,
    //con lo que se iluminan los leds impares, y esperamos 2*DELAY
    outb(output,DATAPORT);
    usleep(2*DELAY);
 
    //Desplazamos los bits de output un lugar a la izquierda,
    //con lo que nos queda "10101010"
    output = output << 1;
 
    //Al pasarlo al puerto paralelo se iluminan los leds pares
    outb(output,DATAPORT);
    usleep(2*DELAY);
  }
}
 
//Esta función enciende ulas luces al estilo del coche fantastico
void ZigZag()
{
  //output solo tiene el último bit distinto de 0
  int output = 1;
  //direction indica el sentido de movimiento de la luz: 1 izquierda,
  // 0 derecha. Empezamos hacia la derecha
  int direction = 1;
  while (output !=0)
  {
    //Sacamos output por el puerto
    outb(output, DATAPORT);
    usleep(DELAY);
 
    //Si dirección es distinto de cero
    //movemos los bits de output hacia la izquierda
    if(direction)
      output = output << 1;
    //Si no, los movemos hacia la derecha
    else
      output = output >> 1;
 
    //Si output vale 256 es que se nos ha salido
    //la luz por la izquierda así que cambiamos la dirección
    if(output==256)
    {
      output = output >> 1;
      direction = !direction;
    }
  }
}