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.

Entre todos los pdfs de su web, hay uno que nos ha llamado especialmente la atención: una lista de soportes analógicos y digitales de grabación y reproducción de audio (PDF, 123 KB). Como estos días andamos liadillos con esto de los formatos de conservación de información, esta lista nos ha ampliado notablemente los horizontes: desde el cassette al DVD-RAM BWF, con su precio, calidad, editabilidad, etc. Hay tanto formatos domésticos como profesionales, y todos ellos se usan hoy en día en mayor o menor medida (o sea, no hay ninguno totalmente obsoleto).

También nos vendrá al pelo una lista de formatos digitales de sonido (PDF, 60KB), que tal vez tengamos más frescos, pero conviene ponerlos todos sobre el papel.

¿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;
}

Click para ampliar (ojo que es grandecito)

Considéralo la piedra de Rosetta de la informática. Una herramienta que te permite comunicarte mucho más fácilmente con google, que te permite decirle exactamente lo que estás buscando. Y está muy completo (los sockets de procesadores van desde el 8086 hasta el futuro, literalmente). A nosotros, desde luego, nos viene de perlas.

Posiblemente el mayor logro de la FSF en el ámbito jurídico es la General Public License (GPL), licencia que permite la libertad de la copia y distribución comercial. Para poder plasmar jurídicamente la GPL Stallman inventa el concepto Copyleft…

Axelrod afirma que la teoría de “Tit for Tat” lleva implícito que nadie busca mayor recompensa que los demás, y se siente feliz si el otro tiene el mismo premio que uno mismo. Al extrapolarlo al movimiento del software libre significa desear que todos tengan las mismas libertades de las que dispone uno mismo. De acuerdo con esta idea, la teoría de “Tit for Tat” permitiría que los individuos cooperen entre sí prosperando desde pequeños enclaves locales a mayores, de forma que se vayan extendiendo a otras áreas dominadas por individuos egoístas. Como la cooperación es un fenómeno que produce retroalimentación positiva y nuestra sociedad conserva un cierto tono proselitista, se deduce que por ello mucha gente acaba participando activamente en el desarrollo de este tipo de proyectos.

En el movimiento del software libre conviven individuos que apoyan un planteamiento centrado en el mejor resultado de productividad que se obtiene bajo la estructura del modelo bazar, manteniendo en todo momento una postura pragmática, rechazando cualquier formulación ética del modelo, junto con otros que sitúan en primer plano valores como la cooperación y libertad. Este modelo deja de tener sentido cuando el trabajo se realiza con objetivos que divergen a los planteados al inicio, es decir, invertir esfuerzo y dedicación con el objetivo de trabajar para el desarrollo de un conocimiento común, tal y como describen algunos hackers, tener la sensación de formar parte de algo más grande que uno mismo. El problema puede presentarse si en un momento dado el objetivo cambia de elaborar en red un software libre a elaborar un software gratis, ya que se esto puede llegar a desmoronar el sistema de cooperación sin mando, diluyendo la comunidad, y por tanto dejando el sistema inutilizado.

¿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

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.