For English version click here

Interconexión de puertos paralelos de la forma más fácil: Circuitos simples y programas para mostrar cómo usar las capacidades de salida de los puertos paralelos de un PC

Copyright Tomi Engdahl 1996-2009

Índice

Introducción

Los puertos paralelos de un PC pueden ser un canal entrada/salida muy útil para conectar sus propios circuitos a un PC. Los puertos paralelos de un PC se pueden usar para llevar a cabo algunos experimentos de conexión de hardware muy interesantes. Son puertos muy fáciles de usar una vez se entienden unos cuantos trucos básicos. Este documento intenta mostrar estos trucos de forma fácil de entender.

ADVERTENCIA: Los puertos paralelos de un PC se pueden dañar muy fácilmente si se cometen errores en los circuitos a los que se conectan. Si el puerto paralelo se encuentra integrado en la placa madre (como es el caso de la mayoría de los nuevos ordenadores), reparar el puerto paralelo dañado puedo resultar caro (en muchos casos sale más barato directamente sustituir la placa madre que reparar el puerto). Su mejor opción es comprar una tarjeta de entrada/salida barata con un puerto paralelo extra y usar éste para sus experimentos. Si daña el puerto paralelo de la tarjeta, sustituir ésta es fácil y barato.

NOTA: Los detalles de control de nivel del puerto de entrada/salida que se comentan en este artículo, se ha demostrado que funcionan correctamente con puertos paralelos en la placa madre del PC y en tarjetas de expansión conectadas a bus ISA. Los ejemplos de programación pueden no funcionar con tarjetas de entrada/salida basadas en bus PCI (pueden usar hardware y/o direcciones de entrada/salida diferentes, son sus drivers los que les hacen actuar como puertos paralelos frente a aplicaciones “normales”). Los ejemplos de programación no funcionan con adaptadores USB a puerto paralelo (éstos usan hardware totalmente diferente, son también sus drivers los que los hacen parecer puertos paralelos normales frente a las aplicaciones “normales” del sistema operativo).

EXENCIÓN DE RESPONSABILIDAD: Se ha tomado toda precaución razonable a la hora de producir esta información. Aún así, el autor no acepta ninguna responsabilidad por el efecto que esta información pueda tener en su equipo ni por ninguno de los resultados del uso de esta información. Es la responsabilidad del usuario final determinar la validez de uso para cualquier objetivo particular. Los circuitos y el software mostrados aquí son para uso no comercial sin necesidad del permiso del autor.

Cómo conectar circuitos a un puerto paralelo

El puerto paralelo de un PC es un conector hembra en forma de “D” de 25 clavijas que se puede encontrar en la parte trasera del ordenador. Normalmente se usa para el ordenador a una impresionar, pero hay muchos otros tipos de hardware que se pueden conectar a través de este puerto.

No todas las 25 se necesitan siempre. Normalmente se puede pasar con 8 clavijas de salida (líneas de datos) y una base de señal. He presentado estas clavijas en la tabla de debajo. Estas clavijas de salida sirven para varios objetivos.

clavija función
 2       D0
 3       D1
 4       D2
 5       D3
 6       D4
 7       D5
 8       D6
 9       D7

Las clavijas 18,19,20,21,22,23,24 y 25 son todas clavijas suelo.

Estas clavijas de datos son clavijas de salida de nivel TTL. Eso significa que idealmente sacan 0V cuando están en un nivel lógico bajo (0) y +5V cuando se están en un nivel lógico alto (1). En la realidad, los voltajes pueden ser ligeramente diferentes de los ideales cuando el circuito se encuentra cargado. La capacidad de salida de corriente de los puertos paralelos está limitada a sólo algunos miliamperes.

Aquí se muestra una idea simple sobre cómo se puede conectar carga a clavijas de datos de los puertos paralelos de un PC.

        Dn Salida ------+
                        |+
  Fuente               Load (hasta 2.6 mA @ 2.4 v)
                        |-
            Suelo ------+

Ésta no es la única forma de conectar cosas a un puerto paralelo.

Las clavijas de datos de los puertos paralelos son salidas TTL, que se pueden tanto enterrar como actuar como fuente de corriente. En implementaciones ordinarias de puertos paralelos las salidas de datos son salidas tótem TTL 74LS374 de circuito integrado que pueden servir 2.6mA y enterrar 24mA.

Las salidas TTL normales consisten básicamente de dos transistores “amontonados” en serie entre +5V y tierra, con la salida viniendo de la conexión entre ellos. Eso se llama una “salida tótem”. En cualquier momento dado, uno de estos dos transistores está conduciendo y el otro no. Para conseguir una salida “alta”, el transistor de +5 a la salida conduce (H), lo que sirve corriente positiva de la salida a tierra (esto significa que un dispositivo externo que se conecte entre la salida y el suelo recibirá electricidad). Para conseguir una salida baja, consiste únicamente el transistor bajo (L), “enterrando” la corriente en tierra; un dispositivo externo entre +5 volts y la salida puede tener energía.

    +5      
        /    	     |
    ---H encendido  V      
        \            -->   
         |________  salida TTL encendida=1=alto, "sirviendo" corriente
         | fuera  \
        /         / |
    ---L apagado  \ V
        \_________/
        Tierra      


       +5_________
        /         \
    ---H apagado  / |
        \         \ V
         |________/  salida TTL apagada=0=bajo, "enterrando" corriente
         |  <-- fuera
        /
    ---L encendido |
        \   V
        Tierra      
  

Las salidas están diseñadas para que sirvan como mínimo 2.4V a una carga de 2.6mA. La cifra 2.6mA es válida para los circuitos ordinarios LS-TTL, las implementaciones LSI usadas en muchos ordenadores pueden dar menos o más. Por ejemplo, el chip de puerto paralelo UM82C11-C bastante popular hace unos años, sólo puede servir 2mA.

Conexión simple para enterrar carga de corriente:

        Dn salida ------+
                        |+
  Sirviendo           Carga (hasta 2.6 mA a 2.4 v)
                        |-
        Tierra ---------+

Al tomar corriente del puerto paralelo de un PC, mantenga la carga baja, no más de unos pocos miliamperes. Intentar tomar mucho corriente (por ejemplo, acortando las clavijas al suelo) puedo freír el puerto paralelo. En mi caso, no he roto (aún) ningún puerto paralelo con este método, pero he tenido casos en los que un exceso de carga ha calentado mucho el puerto IC. Proceda con cuidado.

Si tiene una fuente de +5 volts externa, tiene otra opción de conexión: usar las clavijas de salida de datos para enterrar hasta 24mA de su fuente de +5 volts. Esto se puede hacer con un circuito de este tipo:

                    +------------------------------- (+5 v)
                     |+
   Enterrando       Carga (hasta 24 mA a 4.2v)
                     |-	     Fuente de energía
        Dn Salida ------+

        Tierra -------------------------------------- (Tierra)

La carga consigue potencia y de esta forma se obtiene +5V externos y el puerto de datos de la impresora se encuentra a 0. Este circuito le da la capacidad de conducir más corriente que la opción de “enterrar”. Tiene que ir con cuidado con este circuito, porque en este circuito puede freír el puerto paralelo muy fácilmente si hace algo mal. Mi recomendación es proceder con atención con este tipo de circuito y asegurarse que la fuente de energía externa se apaga cuando se apaga el ordenador (a los puertos de impresora puede no gustarles recibir una aportación de energía de +5V a través del puerto de carga de la impresora cuando éstos no están encendidos). La fuente externa de +5V más conveniente probablemente sea otro puerto de su ordenador (USB, joystick, teclado/ratón, etc…)

Yo he usado mayoritariamente circuitos del tipo “enterrando” y este artículo está centrado en éstos.

Circuitos simples conductores de LED

Usted puede hacer circuitos simples para conducir un pequeño LED a través del puerto paralelo de un PC. Los únicos componentes necesarios son un LED y una resistencia de 470 Ohm. Simplemente tiene que conectar el diodo y la resistencia en serie. La resistencia es necesaria para limitar la corriente que se toma del puerto paralelo a un valor que pueda encender LED aceptablemente normales manteniendo al mismo tiempo un valor seguro (sin sobrecargar el chip del puerto paralelo). En un caso práctico, la salida de corriente será de unos poco miliamperes para el LED, lo que hará que un LED típico se ilumine ligeramente, pero no sacará toda su luminosidad.

LED and resistor

A continuación, puede conectar el circuito al puerto paralelo de forma que uno de los extremos del circuito vaya a una clavija de datos (la que utilizará para controlar el LED) y otra vaya a cualquiera de las clavijas tierra. Asegúrese que conecta el LED en el circuito de forma que la parte positiva (la más larga) vaya a la clavija de datos. Si pone el LED al revés, éste no se encenderá nunca. Puede conectar un circuito a cada una de las clavijas de datos del puerto paralelo. De esta forma, obtiene 8 LEDs controlables por software.

LEDs wired to parallel port

El control por software es fácil. Cuando envía un 1 a través de la clavija de datos, el LED está conectado y se encenderá. Cuando envíe un 0 en esta misma clavija, el LED dejará de encenderse.

Aquí pueden ver dos fotografías del circuito de este tipo que yo he construido:

LEDs wired to parallel port circuit photo 1
LEDs wired to parallel port circuit photo 2

En estos circuitos he conectado el cable tierra a sólo una clavija de tierra (también funciona bien, puede usar cualquiera de las clavijas de tierra).

Especificaciones técnicas de las clavijas de los puertos paralelos

Las especificaciones de IBM según http://www.epanorama.net/counter.php?url=http://www.linux.com/howtos/IO-Port-Programming-6.shtml dicen lo siguiente: Las clavijas de salida de datos (clavijas 2-9) entierran 24mA, sirven 15mA y su nivel alto de salida es como mínimo 2.4V. El estado bajo para ambos es máximo 0.5V. Las clavijas 1, 14, 16 y 17 (los controles de salida) tienen drivers de colector abiertos llevados a 5V a través de resistencias de 4.7kiloohm (entierran 20mA, sirven 0.55mA, nivel alto de salida de 5.0V menos pullup). Los puertos paralelos que no sean de IBM probablemente se desvíen de este estándar.

Advertencia: Proceda con cuidado al conectar a tierra. Puede estropear puertos paralelos al conectarles dispositivos cando el ordenador se encuentra encendido. No es una buena idea acortar las clavijas a tierra o +5V, esto puede dañar los puertos. Probablemente sea una buena idea usar puertos paralelos no integrados en la placa madre para hacer cosas de este tipo. (Normalmente puede conseguir un segundo puerto paralelo para su ordenador con una tarjeta estándar “multi-I/O” barata).

Programas de control para DOS (y Win9x)

El programa siguiente es un ejemplo de cómo controlar las clavijas de datos de un puerto paralelo LPT1 a través de su software. Este ejemplo controla directamente los registros del puerto paralelo, de forma que no funciona en algunos sistemas operativos multitarea. Funciona perfectamente en MSDOS. Puede mirar el código Borland Pascal 7.0 (también deberá compilarlo con versiones anteriores) y después descargar el programa compilado LPTOUT.EXE. Esto ha funcionado perfectamente para mí en sistemas DOS y sistemas Windows 95/98. En algunos tests recientes, este programa funciona de forma intermitente en algunos sistemas Windows 2000.

Program lpt1_output;

Uses Dos;

Var
   addr:word;
   data:byte;
   e:integer;

Begin
   addr:=MemW[$0040:$0008];
   Val(ParamStr(1),data,e);
   Port[addr]:=data;
End.

Cómo usar el programa

LPTOUT.EXE es un programa muy fácil de usar. El programa toma un parámetro, que es valor de datos enviado al puerto paralelo. Este valor tiene que ser entero en formato decimal (por ejemplo 255). También se pueden usar números hexadecimales, pero tienen que ir precedidos por el símbolo $ (por ejemplo $FF). El programa no tiene ningún tipo de comprobador de errores para mantenerlo simple. Si el número que da no se encuentra en el formato correcto, el programa enviará algún valor extraño al puerto.

NOTA: He descubierto que este programa no funciona correctamente en algunos sistemas Windows 2000. Lo he comprobado, pero no sé qué causa este problema específico (a parte del hecho que no debería intentar acceder directamente a hardware en sistemas basados en Windows NT). No he probado este programa en Windows XP.

Ejemplo de cómo usar el programa

LPTOUT 0
Establece todas las clavijas de datos a nivel bajo.

LPTOUT 255
Establece todas las clavijas de datos a nivel alto.

LPTOUT 1
Establece la clavija de datos D0 a nivel alto y todas las otras a nivel bajo.

Cómo calcular sus propios valores a enviar al programa

Tiene que pensar en el valor que da al programa cómo si fuera un número binario. Cada bit del número binario controla un bit de salida. La siguiente tabla describe la relación de bits, clavijas de salida del puerto paralelo y valor de estos bits.

Clavija     2   3   4   5   6   7   8   9
Bit         D0  D1  D2  D3  D4  D5  D6  D7
Valor       1   2   4   8   16  32  64  128
Por ejemplo, si quiere establecer las clavijas 2 y 3 a lógico 1 (LED encendido) tiene que sacar el valor 1+2=3. Si quiere encender las clavijas 3, 5, y 6 tiene que sacar el valor 2+8+16=26. De esta forma puede calcular el valor de cualquier combinación de bits que quiera sacar.

Modificando el código fuente

Puede cambiar fácilmente el número del puerto paralelo en el código fuente simplemente cambiando la dirección de memoria donde el programa lee la dirección del puerto paralelo. Para más información, eche un vistazo a la tabla siguiente.

Format of BIOS Data Segment at segment 40h:
Offset  Size    Description
 08h    WORD    Base I/O address of 1st parallel I/O port, zero if none
 0Ah    WORD    Base I/O address of 2nd parallel I/O port, zero if none
 0Ch    WORD    Base I/O address of 3rd parallel I/O port, zero if none
 0Eh    WORD    [non-PS] Base I/O address of 4th parallel I/O port, zero if none

Por ejemplo sustituya la línea addr:=MemW[$0040:$0008]; en el código fuente por addr:=MemW[$0040:$000A]; si quiere la salida por el LPT2.

En vez de intentar leer la dirección del bloque de información de DOS, siempre puede usar la dirección entrada/salida fijada en el código fuente. El puerto LPT1 se encuentra normalmente a la dirección entrada/salida 378h o 3BCh.

Para encontrar la dirección del puerto puede usar por ejemplo el método: En sistemas Windows modernos (Yo lo probé en Windows 2000) puede la dirección entrada/salida del puerto paralelo en el administrador de dispositivos. Primero abra el administrador de dispositivos (inicio – configuración – panel de control – sistema – hardware – administrador de dispositivos). Una vez allí, selecciones el puerto que le interesa en la sección Puertos (COM y LPT). Con el botón derecho del botón se le abrirá un menú en el que debe seleccionar Propiedades. Una vez allí, selecciones Recursos y se le abrirá una ventana como ésta:

Windows device control IO address view

Los detalles en esta imagen son del puerto paralelo integrado en la placa madre de mi PC.

Programación de puertos paralelos en DOS

Los ejemplos siguientes son ejemplos de código pequeño sobre cómo programar para puertos entrada/salida usando diferentes lenguajes. En los ejemplos he usado la dirección entrada/salida 378h, que es una de las direcciones donde puede encontrarse el puerto paralelo.

Las configuraciones típicas de direcciones para puertos paralelos de entrada/salida en PCs con bus ISA son:

Éstas son las direcciones típicas entrada/salida en los sistemas basados en bus ISA. En los sistemas basados en bus PCI, el puerto LPT1 de la placa madre normalmente se encuentra en la dirección entrada/salida 378h o 3BCh. Si el sistema tiene puertos LPT extra en una tarjeta multi-IO en un bus PCI, estos puertos LPT funcionan diferente de los puertos paralelos “normales” descritos en este documento y no se pueden aplicar los mismos métodos de control (se encuentran en direcciones entrada/salida diferentes y podrían llevar un sistema de control de registro diferente que podría ser específico de la tarjeta, el driver que viene con la tarjeta es el que lo hace parece como un puerto LPT normal frente a las aplicaciones que usan las rutinas de impresión estándar del sistema operativo).

Los ejemplos siguientes son para el sistema DOS (pueden, o no, funcionar en otros sistemas). Los ejemplos de código están diseñados para ser usados con un puerto LPT1 en dirección de entrada/salida 378h.

Ensamblador

MOV DX,0378H
MOV AL,n
OUT DX,AL 
Donde n son los datos que quiere sacar.

BASIC

OUT &H378, N
Donde n es el número que quiere sacar.

C

 
outp(0x378,n);
or
outportb(0x378,n);
Donde n son los datos que quiere sacar. El comando de control del puerto de entrada/salida es diferente según el compilador, puesto que no forma parte de las librerías estandarizadas de C.

Aquí hay un ejemplo de código fuente para el compilador Borland C++ 3.1:

#include <stdio.h>
#include <dos.h>
#include <conio.h>

/********************************************/
/*Este programa establece la salidas del puerto paralelo*/
/********************************************/

void main (void)
{
clrscr();             /* limpiar pantalla */
outportb(0x378,0xff); /* sacar los datos al puerto paralelo */
getch();              /* esperar pulsión sobre una tecla para salir */
}

Usando DOS debug para acceder al puerto paralelo

El programa Debug de DOS es un simple ensamblador 8088 que viene con el sistema operativo DOS (también se puede encontrar en las utilidades DOS de lo sistemas Windows más modernos). El programa Debug permite depurar aplicaciones DOS simples de 16-bit (no sirve para programas Windows modernos de 32-bit). Debug es un programa que tiene integradas varias herramientas de depuración para leer y escribir puertos de entrada/salida.

o- escribe un byte de datos al puerto entrada/salida especificado
SYNTAX o port value
port – especifica la dirección del puerto. La dirección del puerto puede ser un valor de 8 o 16 bit.
value – especifica el valor a escribir en el puerto de entrada/salida. Es un valor de 8 bit. 
i- lee un byte de datos del puerto entrada/salida especificado.
SYNTAX i port
port – especifica la dirección del puerto. La dirección del puerto puede ser un valor de 8 o 16 bit.

Ejemplos:

Si escribe

o 3bc ff

El programa debug sacará el valor ff (hex) al puerto 3bc (hex). 

Si escribe
 
i 3bc
 
El programa debug mostrará 1 byte de datos del puerto paralelo.

Control de puertos paralelos en programas Windows

Escribir programas para hablar con los puertos paralelos era bastante fácil en los viejos días de DOS y también en los de Win95/98. Podemos usar tranquilamente Inporb y Outporb o las funciones or_inp(), or_outp en nuestros programas sin ningún problema si estamos ejecutando el programa en DOS o Win95/98, pero entrando la nueva era de sistemas operativos clones del NT como WIN NT4, WIN2000 y WINXP, toda esta simplicidad se pierde.

En Windows 3.x y Windows 95 es posible el control directo de puertos paralelos a través de aplicaciones de 16-bit y librerías DLL. Así que puede usar el ejemplo en C anterior en Windows 3.x y Windows 95 si hace que su programa sea una aplicación de 16-bit. Si quiere controlar puertos paralelos con Visual Basic o Delphi puede echar un vistazo a las librerías Parallel Port Central en http://www.epanorama.net/counter.php?url=http://www.lvr.com/parport.htm.

El control directo de puertos a través de aplicaciones no es posible en Windows NT, de forma que para controlar los puertos paralelos directamente hay que escribir algún tipo de driver para su dispositivo. Puede encontrar este tipo de drivers en Parallel Port Central y Inpout32.dll for WIN NT/2000/XP.

Driverlinx PortIO en http://www.epanorama.net/counter.php?url=http://www.driverlinx.com/DownLoad/DlPortIO.htm es un driver al que vale la pena echarle un vistazo si quiere acceder a puertos entrada/salida en Windows 95/NT (también funciona bien con Windows 2000). Este software gratuito viene con ejemplos de programas (disponibles tanto en ejecutables como en código fuente) sobre cómo acceder a puertos entrada/salida desde programas en Visual Basic y Microsoft Visual C.

La página control entrada/salida usando Visual Basic que se encuentra en http://www.epanorama.net/counter.php?url=http://www.southwest.com.au/~jfuller/vb/vbout.htmdescribe cuán fácil es hacer una simple aplicación en Visual Basic que controle los puertos paralelos de un PC.

Si está buscando un software ya hecho, puede echar un vistazo la página Web del kit Kemo M125 en http://www.epanorama.net/counter.php?url=http://www.kemo-electronic.com/en/module/m125/.El módulo de relé Kemo está diseñado para hasta 8 tipos de electrodomésticos, lámparas o motores diferentes siguiendo un mismo programa (hasta 40V y carga hasta 0,4A DC o 0,3A AC). El módulo es operado por el puerto de impresión LPT1 de la misma forma que en mis ejemplos de circuito de control de puertos paralelos (en este módulo hay un relé de estado sólido conectado para cada una de las ocho clavijas de salida de datos del puerto paralelo). La página de información del kit Kemo M125 tiene software de control disponible para descargar. Estos software permiten el control manual de las salidas y también temporizar operaciones. El software para Windows funciona en Win9x, Win2k y WinXP. También hay ejemplos de programación en C con el código fuente disponible.

Puede encontrar la descripción de un kit de placa de relé de puerto paralelo en http://www.epanorama.net/counter.php?url=http://electronickits.com/kit/complete/elec/ck1601.htm Viene con software de control para Windows y DOS que se puede descargar de su página Web. Este software funciona con Windows 9x/2000/ME/XP. Puede encontrar información sobre utilidades en DOS en http://www.epanorama.net/counter.php?url=http://www.qkits.com/serv/qkits/diy/pages/QK74.asp.

La página de monitores de puertos paralelos en http://www.epanorama.net/counter.php?url=http://neil.fraser.name/software/lpt/ tiene programas que le van a permitir establecer y monitorizar el estado de clavijas de puerto paralelo. Este software está disponible en algunas versiones diferentes que funcionan en sistemas Windows 98 / ME / NT / 2000 / XP y DOS / Windows 3.1 / 95 / 98 / ME. Este software está escrito usando los lenguajes de programación Visual Basic y Euphoria y se encuentra disponible en forma de código fuente.

Más allá del diseño en serie de software de puertos paralelos y de software de conexión de PC VBPortTest en http://www.epanorama.net/counter.php?url=http://www.beyond-designs.com/PC_ports.htm es una herramienta útil. VBPortTest parallel port utility está diseñado para ayudar al testeo y la depuración de interfaces de puerto paralelo. Permite acceso a los tres registros (datos, estado y control) asociados con el puerto paralelo estándar de un PC (SPP). El usuario puede leer y escribir registros de datos y de control. El programa lee continuamente el registro de estado (el registro de estado es de sólo lectura). Los bits de registro individuales se muestran en LEDs con el valor hex para el registro de datos entero. En modo escritura, el usuario puede cambiar bits individuales haciendo clic en el correspondiente LED. Los valores hexadecimales se pueden introducir por teclado. Son posibles los modos bit, byte y strobe byte. En línea se puede encontrar ayuda en forma de materiales de referencia de puertos paralelos que incluyen descripciones de señal y “Centronics handshake timing waveform”. VBPortTest se encuentra disponible para descarga como freeware. Es compatible con Windows 98, ME y XP.

Si quiere programar puertos paralelos en Windows con C/C++ una de las formas de hacerlo es usando el compilador Borland C gratis inpout32.dll. Para más información puede revisar http://hytherion.com/beattidp/comput/pport.htm y http://csjava.occ.cccd.edu/~gilberts/bcc55.html. El segundo enlace es una guía paso a paso muy completa sobre cómo hacer las cosas.

Interfaz API estándar Windows

El API estándar Windows para programar puertos paralelos está pensado para enviar caracteres a la impresora. No está pensado para controlar el encendido o apagado de clavijas simples.

Usando el puerto paralelo para salida digital se puede hacer funcionar con la API normal de Windows con un simple hack. El truco principal es conectar las clavijas 11 (Ocupada) y 12 (Error de papel) a tierra. De otra forma, el driver de hardware pensará que la impresora con la que está hablando está ocupada o experimentando un error y no sacará los datos.

Sólo tiene que enviar un carácter al puerto paralelo y Windows enviará el valor de este carácter a las clavijas de datos del puerto de la impresora y, además, generará un pulso par la línea strobe. El puerto mantendrá el último valor escrito hasta que se escriba otro valor o hasta que el ordenador se apague o hasta que se envíen datos nuevos al puerto. Si saca más de un byte al mismo tiempo, el driver enviará los datos al puerto en secuencia y apagará y encenderá la línea Strobe una vez para cada byte. El intervalo de tiempo depende un poco de cada ordenador.

Esto significa que en un entorno Windows podemos sacar datos por el puerto paralelo. Puede enviar datos hasta a través de la línea de comandos con el comando “copy” de esta forma:

copy somefile.bin LPT1

Esto enviará el contenido del archivo somefile.bin por el puerto paralelo. El valor del último byte del archivo quedará como el estado del puerto paralelo después de la ejecución del comando.

A parte de la necesidad del hack de hardware, hay otras limitaciones en el método de la API de Windows. La API de Windows no tiene soporte nativo para las operaciones de entrada ni para leer el último valor enviado. Aunque el hardware del puerto paralelo lo permite, el driver del software no.

Control de puertos paralelos en Linux

Linux permite acceso a cualquier puerto usando la ioperm syscall. Aquí tienen unas líneas de código para escribir 255 en el puerto de la impresora:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <asm/io.h>

#define base 0x378 /* dirección base del puerto de la impresora */
#define value 255  /* valor numérico a enviar al puerto de la impresora */

main(int argc, char **argv)
{
   if (ioperm(base,1,1))
    fprintf(stderr, "No se pudo obtener el puerto en la base %x\n",), exit(1);

   outb(value, base);
}

Guarde el código fuente en el archivo lpt_test.c y compílelo con el comando:
gcc -O lpt_test.c -o lpt_test

El usuario debe tener privilegios para tener acceso a los puertos para que el programa pueda ejecutarse, de forma que tiene que ser “root” para poder ejecutar este tipo de programas sin problemas de acceso. Si quiere hacer un programa que pueda ejecutar cualquiera primero tiene que establecer la propiedad del archivo a “root” (por ejemplo, compilándolo siendo “root”) y después dar derechos de ejecución a los usuarios y establecer que el programa se ejecute siempre con los derechos del propietario (“root”) dentro de los derechos del usuario que lo ejecuta. Puede establecer que el programa se ejecute con los derechos del propietario con el comando siguiente:

chmod +s lpt_test

Notas sobre el código fuente: Algunas personas han reportado que por algún motivo este código no funciona en sus sistemas. Si tiene problemas para hacerlo funcionar, pruebe haciendo los siguiente cambios al código: sustituya las líneas "#include <unistd.h%gt;" and "#include <asm/io.h>" with line "#include <sys/io.h>" y después sustituya la línea "#define base 0x378" por "#define base 0x0378".

Si quiere un programa más útil, descargue el código fuente de mi programa lptout.c para el control de puertos paralelos. Este programa funciona de forma que puede dar los datos a enviar al puerto paralelo como argumento de la línea de comandos (suporta tanto números decimales como hexadecimales) al programa y éste sacará el valor al puerto paralelo. Puede compilar el código fuente al comando lptout usando la siguiente línea para hacer la compilación:

gcc -O lptout.c -o lptout

Cuando haya compilado el programa puede ejecutarlo fácilmente. Por ejemplo, ejecutar ./lptout 0xFF pondrá todas las clavijas de datos a 1 y ejecutar./lptout 0x00pondrá todas las clavijas de datos a 0.

En algunos sistemas las direcciones de los puertos entrada/salida pueden ser diferentes de las usadas en mi programada de ejemplo. En ese caso, tiene que modificar la dirección en la línea #define base. Hay diferentes formas de conocer la dirección de un puerto. Primero puede probar de encontrar esta información en las herramientas gráficas de configuración. Estas herramientas y su uso son muy diferentes en las distintas distribuciones Linux. También puede probar con algunas herramientas de la línea de comandos:

También he escrito un programa de control más rico en opciones. Portcontrol es un programa de control de puertos de entrada/salida para Linux de uso general. Le permite escribir y leer de los puertos de entrada/salida suportados. Este software permite escribir el valor especificado al puerto, leer el valor dado a la dirección de entrada/salida dada e imprimirlo en la pantalla en diferentes formatos y manipulación bit-level de los datos de puerto. El software portcontrol se encuentra disponible como paquete portcontrol.tarque incluye el código fuente, instrucciones para compilar/instalar e instrucciones de uso. Para más detalles puede revisar el README y el código fuente de portcontrol.c source code.

GUI simple para Linux

He escrito un programa GUI de ejemplo bastante simple para controlar puertos paralelos en un sistema Linux. My GUI simple de control de puertos paralelos está escrito de una forma que le permite controlar las clavijas de los puertos paralelos. Para comprobar cómo se ve, eche un vistazo a la captura de pantalla. .

Esta GUI de control simple está escrita de forma que funciona correctamente en los dos sistemas de escritorio GNOME y KDE. El programa está escrito como un script de bash que utiliza programas zenity y/o kdialog para crear él mismo los menús GUI. El programa necesita que tenga instalado el programa portcontrol en la carpeta /usr/local/sbin/portcontrol en su sistema Linux y que le haya otorgado los privilegios de ejecución necesarios.

Este programa está pensado como un simple ejemplo que usted puede modificar para adaptarlo a su uso. Solamente tiene que descargar menu.sh y empezar a probar usted mismo.

Recomendaciones de programación

Si quiere aprender más sobre programación de puertos entrada/salida, le recomiendo que lea Linux I/O port programming mini-HOWTO.Aquí les extraigo algunas de las recomendaciones de este documento:

Tenga en cuenta que esta forma de acceder a los puertos de entrada/salida sólo funcionará en sistemas i386. Para poder usar ioperm, tiene que incluir las cabeceras necesarias en su software:

#include  /* for libc5 */ 
#include  /* for glibc */ 
La función prototipo es la siguiente:
int ioperm(unsigned long from, unsigned long num, int turn_on); 
Ioperm configura los bits de permiso de acceso al puerto para bytes num empezando por la dirección de puerto del valor turn_on. El uso de ioperm requiere privilegios de “root”. Únicamente los primeros 0x3ff puertos de entrada/salida pueden ser especificados de esta forma. Para más puertos, hay que usar la función iopl. Los permisos no se heredan en fork, pero en exec sí. Esto es útil para dar permiso de acceso a puertos a tareas no privilegiadas. Esta llamada es válida sobretodo para la arquitectura i386. En muchas otras arquitecturas no existe o siempre da error. Cuando hay éxito se retorna un 0. Cuando hay un error, se retorna un -1 y errno se establece en concordancia.

Ioperm es específico de Linux y no debería usarse en programas que pretendan ser portables. Libc5 lo trata como una llamada de sistema y tiene un prototipo en <unistd.h>. Glibc1 no tiene un prototipo. Glibc2 tiene un prototipo en <sys/io.h> y en <sys/perm.h> (evitar este último, puesto que sólo se encuentra disponible en i386).

El acceso entrada/salida puede ser diferente en diferentes plataformas Linux (por ejemplo, alpha isa una librería, libio, para emular inb/outb en programas de usuario).

La descripción de más arriba se centra en el lenguaje de programación C. También debería funcionar en C++. En ensamblador tiene que llamar ioperm() o iopl() como en C, pero después de esto puede usar las instrucciones lectura/escritura del puerto de entrada/salida directamente.

En otros lenguajes, a menos que pueda insertar código ensamblador o C en línea dentro del programa o use una de las llamadas de sistema mencionadas más arriba, lo más fácil seguramente sea escribir un archivo fuente simple en C con funciones para los accesos o retrasos de los puertos entrada/salida que necesite, compile y lo enlace en el resto de su programa. También puede usar /dev/port cómo se ha descrito más arriba.

Librería de programación de clavijas de puertos paralelos en Linux

Si quiere una aproximación de más alto nivel al control de puertos paralelos que el bajo nivel que supone el escribir directamente en los registros de control, también tiene herramientas a su disposición. Parapin es una librería de programación de clavijas de puertos paralelos muy fácil de usar. Puede encontrar este software en http://www.epanorama.net/counter.php?url=http://parapin.sourceforge.net/. Parapin hace que escribir código C bajo Linux que controle las clavijas individuales del puerto paralelo de un PC sea muy fácil. Este tipo de control es muy útil para los proyectos de electrónica que usan los puertos paralelos de un PC que usan los puertos paralelos de un PC como interfaz genérica de entrada/salida.

Parapin va hasta grandes extremos para asolar el programador de la interfaz de programación de puertos paralelos relativamente complexa suministrada por el hardware del PC, haciendo más fácil usar el puerto paralelo para entrada/salida digital.

Parapin suministra una interfaz simple que permite a los programas usar las clavijas del puerto paralelo del PC como entradas o salidas digitales. Parapin simplifica la escritura de código C en Linux que controle las clavijas individuales de los puertos paralelos de un PC. Puede establecer valores TTL lógicos altos o bajos en clavijas de salida u obtener el estado de las clavijas de entrada. Este tipo de control es muy útil en proyectos de electrónica que usan los puertos paralelos de un PC como interfaz de entrada/salida digital genérica.

Parapin tiene dos personalidades: puede ser usado como librería C de espacio de usuario p enlazado como parte de un módulo kernel de Linux. También hay un driver de dispositivo que le da acceso a los permisos para controlar los accesos al puerto. Parapin se escribió con la cabeza puesta en la eficiencia, de forma que Parapin se puede usar para aplicaciones que requieran de una rápida respuesta.

La versión de espacio de usuario de Parapin se encuentra compilada y enlazada como cualquier otra librería de C. Si instaló Parapin en su sistema usando “make install”, la librería libparapin.a) probablemente se instaló en /usr/local/lib. El archivo de cabecera con los prototipos de funciones y otras definiciones de la librería, parapin.h probablemente se encuentre en /usr/local/incluye. Para usar esta librería, primero asegúrese de #include parapin.h en su código fuente en C. Al enlazarlo, añada –lparapin junto con el resto de librerías que esté usando. La inicialización de las librerías de C se lleva a cabo con la función

        int pin_init_user(int lp_base);
el único argumento de la cual, lp_base, específica la dirección base entrada/salida del puerto paralelo que está siendo controlado. Tanto en la versión de espacio de usuario como en la versión kernel, las clavijas se configuran usando las siguientes tres funciones:
        void pin_input_mode(int pins);
        void pin_output_mode(int pins);
        void pin_mode(int pins, int mode);
El argumento “pins” (clavijas) de cada una de las tres funciones acepta las constantes LP_PINnn. Una vez Parapin ha sido inicializado (Sección 5) y las clavijas se han configurado como clavijas de salida (Sección 6), puede establecer valores en estas clavijas usando las siguientes funciones:
        void set_pin(int pins);
        void clear_pin(int pins);
        void change_pin(int pins, int state);

El valor establecido por el “extremo más lejano” puede ser buscado usando la siguiente función. Por favor, nótese que el estado de la clavija sólo se puede consultar en las clavijas de entrada (por hardware o establecidas como de entrada).
        int pin_is_set(int pins);

Si quiere usar la versión kernel de parapin desde un programa de espacio de usuario sin escribir su propio driver hardware-específico, puede cargar el módulo parapindriver después de cargar kparapin. Este dispositivo expone la funcionalidad de kparapin a través de una interfaz carácter-dispositivo normal (excepto para uso interrumpido). Las principales ventajas son que la funcionalidad de puertos paralelos de parapin puede ser controlada a través de permisos filesystem /dev y toda interacción se hace a través de llamadas de sistema orientadas a dispositivo estándar como open(), close(), i ioctl(). Al construir un programa de espacio de usuario que va a hacer uso de la interfaz parapindriver para kparapin, tiene que incluir parapindriver.h. Este archivo de cabecera define los comandos ioctl específicos de cada dispositivo usados para comunicar con el driver del dispositivo. También incluye parapin.h, de forma que su programa pueda hacer uso de las constantes “LP_*”. Las llamadas de sistema parapindriver toman argumentos usando estas constantes y las pasan sin cambiarlas a las rutinas kparapin.

Una vez que parapindriver se ha cargado correctamente y la entrada /dev correspondiente se encuentra en su sitio, la inicialización y terminación de un puerto paralelo son tareas sencillas. Para inicializar el sistema parapin, sólo tiene que llamar open(2) en la entrada /dev como haría con cualquier otro archivo de dispositivo: int device; device = open("/dev/", 0); if (device < 0) { fprintf(stderr, "device open failed\n"); exit(-1); } El nombre del dispositivo es normalmente parport0, parport1, parport2, etc... (como se encuentra en el sistema Linux Fedora Core 4). Para cerrar el sistema parapin lo único que tiene que hacer es llamar close(2):

       close(device);
Cuando está usando la interfaz de driver parapindriver, toda funcionalidad relacionada con las clavijas del puerto paralelos se invoca con la llamada ioctl(2). Los comandos ioctl para parapindriver se encuentran definidos en el archivo de cabecera parapindriver.h. Los dos usados para establecer clavijas como de entrada o de salida son “PPDRV_IOC_PINMODE_OUT” y “PPDRV_IOC_PINMODE_IN”, respectivamente. Ejemplos:
        ioctl(device, PPDRV_IOC_PINMODE_OUT, LP_PIN01 | LP_PIN02);
        ioctl(device, PPDRV_IOC_PINMODE_IN, LP_PIN11);
Establecer el estado de una clavija a través del driver del dispositivo sigue las mismas normas que las descritas más arriba. Los comandos ioctl usados son “PPDRV_IOC_PINSET” y “PPDRV_IOC_PINCLEAR”.
        ioctl(device, PPDRV_IOC_PINSET, LP_PIN01 | LP_PIN02);
        ioctl(device, PPDRV_IOC_PINCLEAR, LP_PIN01);
Para consultar el estado de una clavija a través del driver de dispositivo hay que seguir las mismas normas que ya se han descrito más arriba. El comando ioctl usado es “PPDRV_IOC_PINGET”. Nótese que el estado de las clavijas sólo se puede consultar de las clavijas de entrada (por hardware o establecidas como de entrada).
        int value;
        value = ioctl(device, PPDRV_IOC_PINGET, DATA);
Los argumentos para estas llamadas ioctl usan exactamente las mismas constantes que las usadas para las versiones espacio de usuario y kernel del mismo parapin. Los valores de retorno de estas llamadas ioctl son los mismos que los definidos para las correspondientes funciones kparapin (más valor -ENOTTY indica que se ha transmitido un valor de comando inválido).

Las clavijas de puerto paralelo son accedidas con constantes de la formas LP_PIN más el número de la clavija de puerto paralelo. Por ejemplo, LP_PIN02 se refiere a la clavija de puerto paralelo 2 que es la clavija de salida de datos D0. Recomendación de programación: normalmente, es más conveniente usar enunciados #define para dar a las clavijas nombres lógicos que tengan significado en el contexto de su aplicación. Ejemplo:

        #include "parapin.h"

        #define VCC LP_PIN02
        #define CS  LP_PIN03
        #define CLK LP_PIN04
        #define D0  LP_PIN10 /* clavija de entrada */
        ...
        clear_pin(CS);  /* obtener Chip Select bajo, decirle de obtener */
        ...
        set_pin(CLK);   /* cronométralo */
        clear_pin(CLK);

Parapin también soporta interrupciones a través del puerto paralelo. Actualmente, parapin sólo soporta un puerto paralelo al mismo tiempo. Muchas de las nuevas distribuciones Linux incluyen el driver de dispositivo parport kernel ya integrado en el sistema y listo para usar.

Puede encontrar la documentación de Parapin en http://www.epanorama.net/counter.php?url=http://parapin.sourceforge.net/doc/parapin.html. La mayoría de las descripciones de parapin que se encuentran en este artículo son una forma editada de la documentación encontrada en esta dirección.

Otros software Linux de control de puertos paralelos

Parashelles un programa que le permite controlar el puerto paralelo (entrada y salida) usando argumentos simples de la línea de comandos. Gracias a su simple interfaz, todo lo que tiene que saber es la dirección del puerto paralelo (por ejemplo, 0x378, 0x3bc, etc.) y un poco sobre binario. Este software se puede encontrar en http://www.epanorama.net/counter.php?url=http://parashell.sourceforge.net/ Ejemplo de uso:

/usr/local/bin/parashell 0x378 VALOR
Dónde valor es el valor numérico que quiere enviar a las clavijas de datos del puerto paralelo. Parasheel es un programa muy fácil de usar en shell scripts. Parasheel también se puede usar para leer estados de clavijas escritos:
/usr/local/bin/pin 0x378
NOTA: Necesita privilegios de “root” para ejecutar correctamente programas parashell.

MatPLC es otro programa que puede merecer que le eche un vistazo. MatPLC es un programa del tipo PLC para Linux (PLC = Programmable Logic Controller = Controlador Lógico Programable), licenciado bajo la GNU GPL. Este software también puede controlar los puertos paralelos de un PC. La página de inicio de MatPLC se puede encontrar en http://www.epanorama.net/counter.php?url=http://mat.sourceforge.net/.

Controlando puertos paralelos a través de la Web

Es posible construir un sistema que le permita controlar las clavijas del puerto paralelo a través de la red. Para hacer esto, necesita las siguientes partes en su sistema Linux:

Normalmente, el control vía Web de dispositivo de entrada/salida funciona de la forma siguiente:

Normalmente la Web basada en la construcción de la interfaz se puede dividir en dos partes bien diferenciadas: la parte de la interfaz Web (obtener el formulario usado con la información de control al ordenador) y el control del hardware en si mismo

La primera parte incluiría el servidor Web, el control de las páginas Web y los scripts necesarios para recuperar los controles del usuario. Hay una gran selección de lenguajes de scripting que se pueden usar. Los más atractivos para este uso podrían ser Perl, PHP y UNIX shell script (bash). Todos estos se pueden usar para leer los controles del usuario. La segunda parte normalmente requiere ser escrita en el lenguaje C, porque la mayoría de lenguajes de scripting carecen de las opciones necesarias para el control directo de hardware. Para esto el lenguaje C es generalmente la mejor opción. La idea es que el control de hardware de nivel bajo se hace con un programa C simple y después el script (en la parte 1) envía los controles a este programa C de alguna forma (en el caso más simple, ejecuta este programa C con los argumentos de línea de comandos correctos cada vez que el hardware necesita ser controlado).

Ejemplo simple de control CGI-BIN

En este ejemplo la idea es que usted hace una página Web que tiene los botones de control con los controles que usted quiere hacer. Los botones de control se establecen de forma que al presionarlos, el navegador del usuario envía el contenido del formulario a un script CGI-BIN. Esta llamada provoca que el servidor Web ejecute el script CGI-BIN especificado. El script CGI-BIN está escrito para llevar a cabo el control necesario, normalmente llamando al programa de control de puertos paralelos con los parámetros correctos.

Esta es la idea básica sobre cómo hacerlo.

Aquí hay un ejemplo simple de una aplicación de control Web. Haga lo siguiente para hacerla funcionar:

1. Asegúrese que su sistema está ejecutando un servidor Web Apache. La mayoría de las distribuciones Linux modernas ya vienen con este software de servidor Web. Asegúrese que tiene instalado Apache. Los pasos siguientes requieren que usted esté corriendo un sistema Linux con un servidor Apache correctamente configurado (la configuración por defecto de Red Hat 7.2 es válida). Considero que las páginas relacionadas al material que estamos tratando se encuentran en el directorio /var/www/ (este es el caso típico en los sistemas Linux Red Hat, en otras distribuciones esta ruta puede ser diferente, cambie los ejemplos como sea necesario si este es su caso). Asegúrese que su servidor Web se está ejecutando. Si no lo está, lo puede iniciar con el siguiente comando (en la mayoría de sistemas necesitará ser “root” para hacer esto):

/sbin/service httpd start
Asegúrese que puede acceder a su ordenador Linux con su navegador Web (corriendo en el mismo ordenador) cuando Apache esté corriendo el ordenador Linux.

2. Compile el código fuente lptout.c al programa binario lptout, copie el programa a su directorio /usr/sbin/ y establezca los derechos necesarios para que siempre se ejecute como “root”. Puede hacer esto identificándose como “root” y ejecutando los comandos siguientes:

gcc -O lptout.c -o lptout.c
cp lptout /usr/sbin/lptout
chmod +s /usr/sbin/lptout
Esto debería ser todo. Ahora todo el mundo debería ser capaz de ejecutar el comando. Compruebe esto identificándose como algún otro usuario y ejecutando el comando:
/usr/sbin/lptout 0xff
Esto debería encender todas las clavijas de datos del puerto paralelo LPT1 y establecerlas a alto (3.5V). Ejecutando el comando:
/usr/sbin/lptout 0xff
Debería establecer todas las clavijas de salida a bajo (0.1V). Asegúrese que todo esto funciona sin problemas. Compruebe que los puertos realmente sean controlados por este programa con un multímetro o el circuito LED descrito en el principio de este documento.

3. Instale los scripts CGI para el control de los puertos paralelos. Los scripts requeridos son lpton.cgi y lptoff.cgi.. Haga clic en los nombres de los archivos para ver su código fuente, haga uso de “ver código fuente” si lo necesita, guarde estos archivos en su sistema con los nombres lpton.cgi y lptoff.cgi. A continuación, copie estos archivos al directorio CGI-BIN de su servidor Web y délos los permisos de ejecución necesarios. Identifíquese como root y ejecute los comandos siguientes en el directorio donde haya guardado lpton.cgi y lptoff.cgi:

cp lpton.cgi /var/www/cgi-bin/lpton.cgi
cp lptoff.cgi /var/www/cgi-bin/lptoff.cgi
chmod go+rx /var/www/cgi-bin/lpton.cgi
chmod go+rx /var/www/cgi-bin/lptoff.cgi

4. Instale la página Web de control necesaria. En este ejemplo, la página Web necesaria se encuentra en la dirección Web http://www.epanorama.net/counter.php?url=http://elnombredesuservidor/lpt/index.html donde "elnombredesuservidor" significa el nombre o dirección IP del ordenador Linux en el que está ejecutando la aplicación. Necesita el código fuente de la página Web index.html (haga clic sobre el nombre del archivo para ver el código fuente, use “ver código fuente” si es necesario, guarde el archivo a su ordenador con el nombre index.html). Para crear el directorio Web para el control del puerto paralelo haga lo siguiente una vez identificado como “root”:

cd /var/www/html/
mkdir lpt
chmod go+rx lpt
Ahora vaya al directorio donde tiene el archivo index.html y cópielo al directorio creado con los siguientes comando (siguiendo identificado como “root”)
cp index.html /var/www/html/lpt/index.html
chmod go+r /var/www/html/lpt/index.html

5. Compruebe que puede acceder a la página de control en su servidor Linux. Dirija su navegador Web a la dirección http://www.epanorama.net/counter.php?url=http://elnombredesuservidor/lpt/index.html donde “elnombredesuservidor” significa el nombre o la dirección IP de su ordenador Linux. Debería ver una página de control parecida a la siguiente: Web browser view of controlling page

6. Pruebe a hacer clic en los botones de control y compruebe que las clavijas de salida del puerto paralelo cambian de estado como indican los botones.

Puede encontrar todos los archivos necesarios para este proyecto Web simple en un archivo tar llamado weblpt.tar. Simplemente descárguelo en su sistema Linux y descomprímalo a un directorio adecuado con el comando

tar xvf weblpt.tar
Ahora tiene todos los archivos necesarios. Simplemente siga los pasos requeridos con cada uno de ellos y debería tener su aplicación Web de control funcionando correctamente.

NOTA: Esto es un ejemplo simple de control de puertos paralelos por la Web. Este ejemplo probablemente no sea la forma más conveniente o eficiente de hacer el control, pero ha funcionado para mi. Al hacer electrónica que será controlada a través de la Web, siempre hay que tener en cuenta la seguridad de la información relacionada, eso significa que hay que asegurarse que sólo las personas que deberían pueden hacer el control y que nadie puede piratear fácilmente el sistema. Este método tiene riesgos potenciales de seguridad porque el programa lptout siempre se ejecuta con privilegios de “root” (si alguien consigue hacerlo colgarse de alguna manera, puede causar problemas potenciales de seguridad). Para hacer todos los pasos mencionados en este documento necesita estar identificado como “root” en el sistema. Cuando uno está identificado como “root” puede hacer mucho daño a su sistema si comete errores estúpidos.

Control de puertos paralelos usando PHP

Aquí hay otro ejemplo de código fuente para el control de puertos paralelos. Este se me envió por Andrew Nickson para que lo incluyera en esta página Web. Se trata de un script php que permite la escritura de data en cualquier puerto paralelo. Requiere tener un servir Web Apache y una versión decente de PHP instalada en Apache. Muchas distribuciones de Linux ya incluyen estas herramientas si las selecciona al instalar su sistema (si no, tendrá que instalarlas usted mismo).

Picture of controlling web page

Hay dos archivos, uno es el mismo script php y el otro los datos del formulario usados para obtener los datos de entrada del usuario. Para que este script funcione necesita tener en su ordenador el mismo programa lptout del que se ha hablado en los otros ejemplos instalado en /usr/sbin/ con los derechos necesarios para que el servidor Web lo pueda ejecutar.

Aquí puede ver el código fuente de lptout.php / parallel.php:

<?php
/* Program: lptout.php
 * Desc:    Toma los datos del formulario y los envía al programa de control del puerto paralelo (lptout).
 *			Los valores deben ser introducidos en hex (0 - ff)
 *          Requiere que lptout se encuentre en /usr/sbin/
 *          
 *	Por Andrew Nickson (www.re-mastered.co.uk)
 */

?>

<?php

  switch (@$_GET['do'])                               
  {

    case "update":
	{
		echo ("<center><br>Data sent to parallel port (0x$fvalue)</br></center>");

		exec ("/usr/sbin/lptout 0x$fvalue");
		include("parallel.inc");
	}
	break;             

    default:                                             
        include("parallel.inc");
  }
?>

Aquí puede ver el código fuente del archivo parallel.inc file usado por el código fuente anterior. Este código fuente imprime el formulario que se muestra al usuario para el control del puerto paralelo.

<?php
/* Program: Parallel.inc
 * Desc:    Contiene los datos del formulario para el control del puerto paralelo
 *          Esto llamará a parallel.php.
 *         
 *	Por Andrew Nickson 2005 (www.re-mastered.co.uk)
 */
?>

<html>
<head><title>Controlador del Puerto Paralelo</title></head>
<body topmargin="0" leftmargin="0" marginheight="0"
      marginwidth="0">
         <center><form action="parallel.php?do=update" method="POST"> 
         <table border="0">
          <tr><td align=right><b>Value (HEX)</b></td>
             <td><input type="text" name="fvalue" 
                      size="5" maxsize="3">
             </td></tr>
                <br><input type="submit" name="Update" 
                           value="Actualizar">
               </td></tr>
         </table>
</body></html>

Puede descargar estos códigos fuente como un sólo paquete comprimido de nombre lptoutphp.zip.

Control Web usando PHP y AJAX

La interfaz Web del software portcontrol es una interfaz Web moderna simple para el control de puertos paralelos. Este software está basado en software PHP corriendo en un servidor Linux y una aplicación cliente JavaScript corriendo en el navegador del usuario. De esta forma es posible obtener el estado de las clavijas de datos del puerto paralelo en la pantalla prácticamente a tiempo real y de forma bonita y flexible y fácil de controlar.

Por el lado del servidor encontramos un software de portcontrol constituido por unas pocas líneas de PHP. Portcontrol es un programa simple de control de puertos de entrada/salida para Linux de uso general. Este programa permite escribir y leer los puertos de entrada/salida suportados. Este programa permite escribir el valor especificado al puerto, leer un valor a una dirección entrada/salida dada e imprimirlo a la pantalla en diferentes formatos y la manipulación de los datos del puerto a nivel de bit.

Port control web interface

El archivo control.php es el que se encarga de la magia del control del puerto. Una vez cargado, el usuario obtiene una página Web y código JavaScript user end. Este código JavaScript pregunta periódicamente (una vez cada 5 segundos) el estado del puerto paralelo al servidor (llamada AJAX) y si éste ha cambiado actualiza la pantalla. También gestiona los botones de control. Cada clic sobre un botón de control hace que el software de control llame al servidor para llevar a cabo la función deseada (llamada AJAX). Cuando el control se ha llevado a cabo, el servidor devuelve el estado actual del puerto (es impreso en la pantalla). Cuando el software de control está escrito de esta forma, funciona bastante bien y se siente prácticamente como si fuera una aplicación que esté controlando los puertos paralelos directamente (a diferencia de la típica aplicación Web que requiere recargar la página cada vez que hace algo).

A parte del propio script de control PHP, también he escrito otra versión del archivo control.php. Este archivo controlfile.php funciona prácticamente de la misma forma, pero en vez de controlar el puerto paralelo, escribe y lee el estado de un archivo (status.txt en el mismo directorio que se encuentra el script). Puede usarlo para testear fácilmente el sistema de control basado en AJAX/PHP desde cualquier parte (no requiere que el ordenador tenga un puerto paralelo real). La aplicación AJAX de testeo de control de puertos basada en un archivo se puede descargar de aquí.

El software de control de puertos con interfaz Web se encuentra disponible como paquete portcontrol.tar que incluye código fuente, instrucciones de compilación/instalación e instrucciones de uso. Para más detalles eche un vistazo al README.

Para usar el software también necesita descargar SAJAX Simple Ajax Toolkit by ModernMethod de http://www.epanorama.net/counter.php?url=http://www.modernmethod.com/sajax/.

Control Web usando PHP y AJAX en sistemas Windows

A causa de varias peticiones he portado a Windows mi sistema Web de control de puertos usando PHP y AJAX. La versión Windows se basa en los siguiente componentes:

To use the package you need to do the following:

Primero tiene que descargar la versión 3.2 de PortableWebAp de http://www.epanorama.net/counter.php?url=http://portablewebap.com/. Se trata de un paquete software gratuito, aunque requiere que se registre para poder descargarlo. PortableWebAp es una plataforma portable para aplicaciones Web. Con ella se pueden correr aplicaciones Web desde un CDROM, DVD, lápiz USB y desde cualquier directorio de cualquier disco duro. No requiere instalación. Escogí este paquete por la simplicidad de la instalación: simplemente descomprima el archivo .zip en el directorio desde el que quiere ejecutarlo. No requiere de instalación ni configuración. El tamaño es de unos 5Mb. El servidor Web para Windows más fácil de configurar que jamás he visto! Puede instalarlo, por ejemplo, en el directorio C:\PortableWebAp3.2

A continuación, necesita descargar el inpout32 driver de http://www.epanorama.net/counter.php?url=http://www.logix4u.net/inpout32.htm. Descargue el archivo .zip que contiene el driver. Descomprímalo a un directorio válido. Copie inpout32.dll a un directorio del sistema donde el sistema pueda encontrarlo. En mi sistema Windows 2000 este directorio es C:\WINNT\system32 directory (este directorio puede ser diferente si usa una versión diferente de Windows).

El tercer componente que necesita es mi paquete con mi script PHP y el prontcontrol.exe. Descargue el paquete WinPortControlAjax.zipAQUÍ. Únicamente descargue el archivo .zip. Cree un directorio llamado portcontrol dentro del directorio C:\PortableWebAp3.2\Program\www\localhost. Ahora descomprima el paquete en este directorio C:\PortableWebAp3.2\Program\www\localhost\portcontrol

Ahora ya tiene todas las partes necesarias para establecer el sistema. La parte siguiente es el testeo:

Inicie PortableWebAp ejecutando el archivo portablewebap.exe en el directorio C:\PortableWebAp3.2. Esto iniciará el servidor Web y también su navegador. Si su ordenador tiene un cortafuegos, éste puede preguntarle si quiere que este programa pueda ejecutarse como servicio/servidor en su ordenador (permita esto). El navegador al iniciarse se dirige a la URL http://www.epanorama.net/counter.php?url=http://localhost:800/ . Escriba la dirección http://www.epanorama.net/counter.php?url=http://localhost:800/portcontrol/control.php en su navegador para acceder a la aplicación de control de puertos. Ahora debería tener en la pantalla una aplicación parecida a la que hemos visto antes en Linux.

Web based port control on Windows

Esto también funciona en Windows. Hay una desventaja en la forma que se implementa este sistema Windows. Puede ser que vea un flash intermitente en la pantalla del ordenador que corre el servidor. Esto es causado porque portcontrol.exe se inicia cada pocos segundos (iniciado por control.php cuando el navegador AJAX le pide una actualización del estado). Cada vez que se inicia portcontrol.exe, su consola Windows aparece (ve la consola Windows porque portcontrol.exe es una aplicación de consola Windows) y se cierra una fracción de segundo más tarde.

Ideas de modificaciones para la interfaz Web

Se me ha preguntado muchas veces cómo preguntar otras clavijas en el puerto paralelo que no sean las clavijas de datos. Aquí hay algunas instrucciones que explican cómo modificar el código fuente de la interfaz Web para hacer precisamente esto.

El programa portcontrol que se encarga del control de puertos en nuestra interfaz ya suporta el control de muchas otras cosas aparte de las clavijas de datos del puerto paralelo. El ejemplo de código en PHP control.php no suporta estas opciones. Si quiere usar estas opciones, tendrá que modificar el código fuente de control.php y cambiar la definición del puerto en éste. Si quiere controlar tanto clavijas de datos como otras clavijas, seguramente sea una buena idea hacer una copia de control.php con otro nombre y hacer las modificaciones en él.

Para hacer modificaciones abra el código php de control de puertos y modifique las líneas siguientes:

En sistemas Windows:

return " Time: " . date("M dS, Y, H:i:s  ") . "Estado: " . shell_exec("portcontrol.exe LPT1DATA read print bin");
shell_exec("portcontrol.exe LPT1DATA read setbit " . $x . " write");
shell_exec("portcontrol.exe LPT1DATA read resetbit " . $x . " write");
En sistemas Linux:
return " Time: " . date("M dS, Y, H:i:s  ") . "Estado: " . shell_exec("/usr/local/sbin/portcontrol LPT1DATA read print bin");
shell_exec("/usr/local/sbin/portcontrol LPT1DATA read setbit " . $x . " write");
shell_exec("/usr/local/sbin/portcontrol LPT1DATA read resetbit " . $x . " write");

Cambiando LPT1DATA por uno de los identificadores de puertos suportados, el control se llevará a cabo en ése puerto:

 *  Identificadores de puerto suportados
 *  LPT1DATA
 *  LPT1STATUS
 *  LPT1HANDSHAKE
 *  JOYSTICK
 *  NONE
Para controlar clavijas de puerto paralelo los puertos a usar son LPT1STATUS y LPT1HANDSHAKE.

Controlando algunos sistemas electrónicos reales

La idea de la interfaz mostrada más arriba se puede expander para controlar algunos dispositivos electrónicos externos simplemente añadiendo un circuito búfer al puerto paralelo. La programación se llevaría a cabo de la misma forma que hemos visto en mis ejemplos.

Construyendo sus propios circuitos de control de relé

El circuito siguiente es la interfaz más simple que puede usar para controlar relé desde el puerto paralelo:

                               Vcc
                                |
                                +------+
                                |    __|__
                             Espiral  /^\  Díodo 1N4002
                             de relé /---\
                                |      |
                                +------+
                                |
                             | / 
                   4.7K    B |/  C
Clavija de control >-\/\/\/--|    Transistor NPN: BC547A o 2N2222A
de datos del puerto paralelo |\  E
                             | V
                               |
Clavija tierra  >--------------+
del puerto paralelo            |
                            Suelo
El circuito puede ocuparse de relés que tomen corrientes de hasta 100mA y operen a 24V o menos. El circuito necesita una fuente de energía externa que tenga la salida de voltaje adecuada para el control del relé (5..24V en función del relé). El transistor se encarga del cambio de corriente y el díodo previene que picos de la espiral de relé dañen a su ordenador (si no pone el díodo, el transistor y su ordenador se pueden dañar).

Como los espirales (solenoides y espirales de relé) tienen una cantidad de inductancia muy grande, cuando se liberan (cuando se corta la corriente) generan un poco de voltaje muy grande. La mayoría de los diseños tienen un díodo o un circuito de palanca para impedir que esta subida de voltaje golpee al resto del circuito. Si el díodo es malo, el voltaje puede, con el tiempo, destruir su transistor de “entierro” o hasta su tarjeta de entrada/salida. El modo de fallo del transistor puede ser un cortocircuito y consecuentemente, tendría el solenoide acortado a tierra indefinidamente.

El circuito también se puede usar para controlar otras cargas pequeñas como LEDs potentes, lámparas y pequeños motores DC. Recuerde que los dispositivos que planee controlar directamente con el transistor deben tomar menos de 100mA de corriente.

ADVERTENCIA: Compruebe y vuelva a comprobar el circuito antes de conectarlo a su PC. Usar componentes estropeados o inadecuados puede provocar que su puerto paralelo se estropee. Errores en la construcción del circuito pueden resultar en la pérdida del puerto paralelo y obligarle a comprar una tarjeta multi-IO nueva. El díodo 1N4002 en paralelo con el relé es un componente esencial de protección y nunca debería ser dejado fuera del circuito o su puerto paralelo se puede ver dañado a causa del gran pico de voltaje que provoca la alta inductancia del relé (el díodo se encarga de evitar este pico).

Nuevo diseño más seguro

El ejemplo de circuito detallado más arriba es correcto y funciona bien. Si por alguna razón B y C tienen que ser juntados y está pidiendo más de +5V por el lado del relé, el circuito puede enviar un voltaje así de alto y con ello dañar el puerto paralelo. El circuito siguiente usa dos díodos 1N4148 para proteger el puerto paralelo de señales más altas de +5V y también contra la polarización equivocada de las señales (la electricidad en el circuito está por error en la polaridad incorrecta).


                               Vcc
                                |
                                +------+
                                |    __|__
                            Espiral   /^\  Díodo 1N4002
                            de relé  /---\
                                |      |
                                +------+
                                |
            Díodo            | /
            1N4148  4.7K   B |/  C
Clavija de  >-|>|-+--\/\/\/--|      Transistor NPN: BC547A o 2N2222A
datos de puerto   |          |\  E
paralelo          +-|<|-+      | V
              1N4148    |      |
Tierra de   >-----------+------+
puerto paralelo                |
                            Tierra

Idea para añadir aún más seguridad: Sustituya el díodo 1N4148 conectado a tierra con un díodo zener de 5.1V. Este díodo protegerá de picos de sobrevoltaje y de voltaje negativo al mismo tiempo.

Ejemplo de circuito mal diseñado

No sé POR QUÉ veo principiantes que aún no PIENSAN muy bien la electrónica, pero aún así insisten en poner el relé “DESPUÉS” del transistor, como si eso fuera algo importante. Pues NO lo es, de hecho, es una MALA PRÁCTICA si quiere que el puerto paralelo funcione bien! Este tipo de circuitos mal diseñados se publican a menudo en los grupos de noticias de electrónica de usenet. EL circuito siguiente es un ejemplo de este tipo de circuitos mal diseñados (no pruebe a construirlo):

                               Vcc
                                |
                             | /
                   4.7K    B |/  C
Puerto paralelo---\/\/\/\/---|       Transistor NPN: BC547A o 2N2222A
                             |\  E
                             | V
                             |
                               +------+
                               |    __|__
                           Espiral   /^\  Diode 1N4002
                           de relé  /---\
                               |      |
                               +------+
                               |
                             Tierra


NOTA: Éste es un mal diseño. No pruebe a construirlo.
El problema de este circuito es que el voltaje que va por el relé siempre se encuentra limitado a 4.5V, aunque use una fuente Vcc mayor. El circuito actúa como un seguidor de emisor, lo que causa que el voltaje en el emisor siempre se encuentre en el valor base de voltaje – base al emisor de voltaje (0.6..0.7V). Esto significa que con el máximo de 5.1V de voltaje controlado, obtendrá un máximo de 4.5V sin importar cual sea el voltaje aportado (cuando sea mayor de 5V y por debajo, el transistor rompe el voltaje).

Otro problema es que en algunos casos este circuito puede empezar a oscilar si la resistencia base se encuentra justo en el extremo.

Circuito básico con aislamiento óptico

Uno de los ejemplos más simples de circuito de salida aislado ópticamente es el siguiente circuito basado en 4N33:

4N33 based parallel port optoisolator

El dispositivo de par óptico 4N33 tiene un transistor de salida Darlington que es capaz de conducir hasta 30mA de forma segura. El voltaje máximo en el lado de salida es de 30V. Uno conecta el lado de entrada + a la clavija de salida del puerto paralelo que quiere usar para el control. A continuación, conecta el lado de entrada – a la clavija tierra del puerto paralelo. El lado de salida se conecta al circuito para ser controlado con la polaridad correcta. En este circuito de ejemplo usé una resistencia de 1Kohm para limitar el control de corriente (el circuito también debería funcionar bien con una resistencia de 470Ohm). Como la corriente que se sirve al par óptico es muy baja (sólo unos mA), la corriente de salida del par óptico disponible garantida es baja. Puede esperar obtener algo parecido a una capacidad de conducción de 10mA en la salida (puede que más si tiene la suerte de tener un acoplador con alto CTR y un puerto paralelo con una alta corriente de salida). El circuito también se puede construir usando un par óptico 4N32 que es muy similar al 4N33.

Datos del componente 4N33:

Los datos del componente se han sacado de la tabla de datos obtenible en http://www.epanorama.net/counter.php?url=http://www.vishay.com/docs/83736/83736.pdf. Estos acopladores ópticos se pueden usar para sustituir relés de caña o de mercurio con las consiguientes ventajas de larga vida, intercambio de alta velocidad y eliminación de los campos magnéticos.

Circuito de acoplador óptico amplificado con transistor

Si quiere tener una muy buena protección de su puerto paralelo y más capacidad de conducción puede considerar el aislamiento óptico usando un circuito de este tipo:

                                                V+  (12V)
                                                 |
                                    +------------+
                                    |            +------+
Puerto                              |            |      |
Paralelo                            |    D1     ---     |
                                    |   1N4001  / \    Espiral de relé
          R1    1  ----------- 5    |          /---\    |
 D(x) ----1k------| Opto-     |-----+            |      |
                  | aislante  |                  +------+
 GND -------------|           |-+                |
                2  ----------- 4|                |
                   CNY 17 o    |   R2        | /
                   4N25         |   4.7K    B |/  C   T1
                                +--\/\/\/\/---|      BC547A o 2N2222A
                                              |\  E
                                              | V
                                                |
                                          Tierra del circuito externo

Asignación de clavijas típica en un opto-aislante (CNY 17 y 4N25):

       -----------------------------
 1--|----          |------------|--6
    |   |          |            |
    | \---/ \      |    ------  |
    |  \ /  \     | | / C   |  |
    |  --- \  \|   | |/     |  |
    |   |   \ --   --|       ---|--5
    |   |    \|    B |\         |
 2--|----    --      | V E      |
    |                   --------|--4
 3--|--NC                       |
    -----------------------------

El opto-aislante está allí para proteger el puerto. Nótese que no hay conexiones entre las partes eléctricas del puerto. El circuito está abastecido por una fuente de energía externa que no está conectada al PC si no hay necesidad de que sea así. Esta disposición previene que alguna corriente en los circuitos externos pueda dañar el puerto paralelo

La entrada del opto-aislante es un díodo emisor de luz. R1 se usar para limitar la corriente cuando la salida del puerto está activada. La resistencia de 1Kohm limita la corriente a alrededor de 3mA, lo que es más que suficiente para la conducción del transistor de salida.

El lado de salida del opto-aislante es como un transistor, con el colector arriba de todo del circuito y el emisor abajo. Cuando se activa la salida (con la luz de entrada del LED interno del opto-aislante), la corriente fluye a través de la resistencia dentro del transistor, encendiéndolo. Esto permite que la corriente fluya dentro del relé. La corriente de salida del opto-aislante con la entrada de corriente explicada arriba debería ser dentro del rango de 1-3mA. (depende del tipo exacto de opto-aislante y de la variación de componentes). Esta corriente pasa a través de R2 en dirección a la base transistor.

Apagando la entrada en el puerto paralelo provoca que la salida del opto-aislante se apague, de forma que ni pasa ninguna corriente a través de éste y hacia el transistor, de forma que éste último también se apaga. Cuando el transistor está apagado, no pasa corriente por el relé y esté también se apaga. El díodo nos ofrece una salida para la energía guardada en el espiral, previniendo así, que este devuelva parte de la corriente al circuito de forma indeseada.

El transistor en el circuito se puede usar para controlar las cargas de salida hasta un máximo de alrededor de 100mA (depende un poco de los componentes y del voltaje de la operación usada). La fuente de energía externa puede estar dentro del rango de 5V a 24V. Cuando use un relé que toma menos de estos 100mA de corriente y funcione con la fuente de energía que use, todo debería ir bien. La carga de salida que usted puede controlar con el circuito con un relé únicamente depende de los ratings de contacto de los relés de salida (máximo corriente y máximo voltaje).

Este circuito también se puede usar directamente para controlar pequeñas cargas (menos de 100mA de corriente). Simplemente coloque la carga que quiera controlar en el sitio del relé.

Datos de componente de algunos de los componentes usados:

Circuito de control aislado ópticamente de alta energía

Aquí hay una versión de alta energía del circuito descrito más arriba:

                                                V+  (12V)
                                                 |
                                    +------------+-----+------+
                                    |                  |      |
Puerto                              |                  |      |
paralelo                            |          D1     ---     |
                                    |         1N4001  / \ Espiral de relé
          R1     1 ----------- 5    |                /---\    |
 D(x) ----1k------| Opto-     |-----+                  |      |
                  | aislante  |                  +-----+------+
 GND -------------|           |-+                |            |
                 2 ----------- 4|                |            |
                   CNY 17 o    |   R2        | /             |
                   4N25         |   4.7K    B |/  C T1        |
                                +--\/\/\/\/---|     BC547A    |
                                |             |\  E           |
                                |             | V          | /
                                /               |        B |/C  T2
                                \  R3           +----------|    power
                                / 10 kohm                  |\E  transistor
                                \                          | v
                                |                            |
                                +----------------------------+
                                                             |
                                                Tierra del circuito externo
En este circuito Q1 se usa para controla la base de corriente de Q1, quien controla la corriente en sí misma. Puede selección prácticamente cualquier transistor para este circuito mientras cumpla sus necesidades de corriente y voltaje. Algunas alternativas a modo de ejemplo son TIP41C (6A 100V) o 2N3055 (100V 15A). En función de su factor heredado de amplificación al transistor Q1, puede que no sea posible usar toda la capacidad de corriente de su dispositivo de salida T2 antes que haya demasiadas perdidas (calor) en este transistor.

Este circuito es básicamente una modificación muy simple del circuito aislante óptico original con un transistor. La diferencia en este circuito es que en este caso T2 controla la carga de corriente y Q1 actúa como un amplificador para el control de corriente base de T2. Los aislantes ópticos R1, R2, Q1, D1 funcionan exactamente de la misma forma que en el circuito de un transistor descrito anteriormente en este documento. R3 actúa como una resistencia extra que garantiza que T2 no conduce cuando no se le da señal al aislante óptico (impide que T1 y T2 conduzcan a causa de un pequeño escape de corriente de la salida del aislante óptico).

Control de la red de suministro de energía con puertos paralelos

Es posible controla el voltaje de la red de suministro a través del puerto paralelo con un circuito adecuado. Cuando se controla el voltaje de la red de suministro hay que proceder con mucha atención y saber qué se está haciendo para hacerlo todo de forma segura. El voltaje de la red de suministro puede matar si se toca directamente y un mal control de la red de suministro puede acabar quemando su casa.

La primera idea para controlar le red de suministro de energía es usar uno de los circuitos de más arriba para control un relé que después controla la red de suministro de energía. Esto funciona con muchas aplicaciones siempre que el relé esté rateado para aplicaciones de intercambio de la red de suministro de energía y para el actual rateo de sus aplicaciones. Un circuito correctamente diseñado debería tener además del relé (más un circuito de interfaz de puerto paralelo) un fusible de tamaño adecuado que cortará la electricidad a través del relé si se produce un cortocircuito o una sobrecarga en el equipamiento controlado. El fusible aquí se usar para proteger el relé frente a una sobrecarga. El relé funcionará bien en aplicaciones que requieran que el dispositivo se apague y se enciende pocas veces. Si va a encender y apagar el dispositivo a menudo, un relé normal se estropeará rápidamente y además, en algunas aplicaciones transmitirá ruido causado por los picos que producen los contactos del relé al abrirse y cerrarse. Estos picos pueden provocar ruido de radiofrecuencia.

Otro componente válido para el control el voltaje de la red de suministro es un relé de estado sólido. El circuito de más abajo muestra cómo controlar un relé de estado sólido a través del puerto paralelo de un PC. El relé de estado sólido controla el voltaje de la red de suministro.

Mains power controlling with solid state relay

El relé para esta aplicación debería de ser rateado para el voltaje de la red de suministro que esté usando y para la corriente de su equipamiento (marcado con una L en la imagen). El relé de estado sólido diseñado para el control de redes de suministro nos provee con el aislamiento requerido entre la entrada de control y el lado de la red de suministro. El relé de estado sólido debería ser usado de acuerdo con las notas de aplicación del fabricante y con los códigos locales de su equipamiento. Es importante que mantenga asilados en todo momento los lados de la red de suministro y de bajo voltaje (hasta en caso de daño del equipamiento). También debería poner un fusible del tamaño adecuado en serie con el relé de estado sólido para proteger el relé frente a una sobrecarga. Un fusible del tamaño adecuado no protegerá el relé frente a un sobrecalentamiento si la carga intenta tomar demasiada corriente a través del relé. Este fusible puede que no sea capaz de proteger su relé frente a daños por cortocircuito (si cortocircuita la carga normalmente pierde ambos el relé de estado sólido y el fusible).

Muchos relés de estado sólido pueden ser controlados directamente por un puerto paralelo sin necesidad de componentes extra. Tiene que seleccionar un relé de estado sólido que sea controlado por voltaje y que el rango de voltaje pueda tomar el voltaje de las salidas del puerto de impresora (5V o un poco menos). Para una operación segura debería seleccionar un relé que pueda operar a menos de 3V de voltaje de entrada y que no tome mucho control de corriente (un SSR que tome pocos miliamperes es mejor porque la capacidad de salida de corriente de los puertos paralelos se encuentra normalmente limitada a estos valores). Para garantizar que la operación es fiable con la conexión directa, asegúrese de medir que el voltaje de control entrando al SSR se encuentra dentro del rango de operación especificado cuando el relé se encuentra controlado por un puerto paralelo (puede mesurarlo sin conectar la red de suministro al resto del circuito, es más seguro de esta forma). Controlar un relé de estado sólido con voltaje de control más bajo puede llevar a una operación poco fiable del relé de estado sólido y puede hasta causar que el relé de estado sólido falle cuando esté altamente cargado!

También se puede construir la parte de control de voltaje de la red de suministro a partir de componentes discretos. Aquí tiene dos ejemplos de circuitos:

110V AC controlling

220V AC controlling

Estas figuras sólo deben servir a modo de ejemplo. No recomiendo que construyan estos circuitos. Hoy en día, los relés de estado sólido se encuentran disponibles a precios muy razonables y con ellos es más fácil construir circuitos de control seguros.

Una cosa muy importante a destacar de los circuitos de control de red de suministro es que deberían ser construidos con mucho cuidado y de forma correcta. El voltaje de la red de suministro puede matar si entra en contacto con él. Un circuito mal construido se puede sobrecalentar y provocar un incendio. Cualquier circuito de control de red de suministro debería ser construido de forma que disponga de protección frente a subidas de corriente y frente a sobrecargas del circuito (normalmente hay suficiente con un fusible en la entrada). Este circuito tiene que ser construido en una caja segura y mecánicamente estable. Una caja de aislamiento de plástico (cajas electrónicas hechas de plástico que no se incendian fácilmente) es una opción. Otra opción es construir el circuito en una caja metálica con toma de tierra. La forma exacta de construir circuitos de control de redes de suministro de energía se escapa al ámbito de este artículo. Debería conocer todos los detalles antes de intentar construir un circuito de este tipo que se conecte a la red de suministro de energía.

Driver compacto de 8 canales de salida

Puede construir un circuito con muchas salidas combinando muchos circuitos basados en un transistor individual. Si quiere tener una construcción compacta de hasta 8 salidas le recomiendo que use el IC ULN2803 fabricado por Allegro y varios otros fabricantes. Aquí les pongo la distribución de clavijas de este IC ULN2803:

ULN2803 pinout

El ULN2803 es un driver Darlington NPN de 8-bit 50V 500mA y entrada TTL. Destacando por ratings de carga de corriente continua 500 mA para cada uno de los drivers, el ULN2803A array de alta corriente Darlington es especialmente adecuado para la interconexión entre circuitos de bajo nivel lógico y múltiples cargas periféricas de electricidad. Las cargas normales incluyen relés, solenoides, motores de pasos, martillos de impresión magnética, LEDs multiplexados y displays incandescentes y calentadores. Los drivers no requieren de una fuente de energía; la clavija VDD “común” es el cátodo común de los ocho díodos de protección integrados. La tabla de datos para este IC se puede encontrar en http://www.epanorama.net/counter.php?url=http://www.allegromicro.com/sf/2801/ y http://www.epanorama.net/counter.php?url=http://impressolibre.sourceforge.net/miniplotter/ULN2803-D.PDF

El ULN2803 está conectado entre cada una de las ocho líneas del puerto de la impresora y el dispositivo que controla. El dispositivo de salida puede ser tan simple como un LED, un pequeño motor o un relé. Las entradas en el lado izquierdo del IC están preparadas para ser conectadas directamente a las líneas de salida del puerto paralelo de un PC. Las salidas son salidas de colector abierto (la salida es llevada a tierra a través de un transistor cuando la línea correspondiente pasa a estado alto), así que son perfectamente válidos para controlar varias cargas abastecidas por una fuente de energía externa. El voltaje controlable máximo es 50V y la corriente máxima por canal es de 500mA. Las salidas pueden ser puestas en paralelo para conseguir una mayor capacidad de carga de corriente. Los lados de entrada y salida del IC tienen la misma tierra y deben ser conectadas también a la clavija de tierra del IC ULN2803.

La línea “común” es conectada a un circuito de protección de sobrevoltaje adecuado para prevenir cualquier daño al IC a causa de “back emf” cuando cargas como motores o relés se enciendan o apaguen. También puede usar por ejemplo un zener de 30V conectado al componente de protección de la línea (limita el abastecimiento de electricidad al relé a un máximo de menos de 30V). O puede conectar un zener de 12V al abastecimiento de electricidad al relé (limita picos de voltaje del abastecimiento de electricidad a 12V, no usar una fuente de energía de más de 30V).

Aquí hay un ejemplo de un circuito de control que conduce hecho LEDs usando el IC ULN2803:

Driving LEDs with ULN2803

Este circuito también se puede usar para conducir otros tipos de cargas, por ejemplo, relés, pequeñas bombillas, etc. Sólo tiene que sustituir los LEDs junto con la combinación de resistencias por la carga que quiera (siempre que la carga se encuentre dentro de las posibilidades de capacidad de salida del drive ULN2803). Para este circuito puede usar por ejemplo un díodo zener de 15V.

Se pueden encontrar otros ejemplos de circuitos implementados con ULN2803 en http://www.epanorama.net/counter.php?url=http://www.southwest.com.au/~jfuller/electronics/integrated.htm y http://www.epanorama.net/counter.php?url=http://www.southwest.com.au/~jfuller/sio5works.htm.

Enlaces a circuitos de salida de puertos paralelos

Enlaces a diagramas de circuitos

Kits / módulos de productos probablemente útiles

Los kits electrónicos siguientes se consideran útiles para los lectores que no quieran construir sus sistemas electrónicos de interfaz desde cero. Estos módulos / kits deberían ser todos controlables de la misma forma que mis ejemplos de más arriba. He testeado personalmente el Kemo M125. La información de los productos está basada en mirar a los diagramas de circuitos y/o operación de su software de control.

Software de control listo para usar

Aquí hay una colección de enlaces a software de control de puertos paralelos listo para usar. Hay una gran variedad de software disponible para diferentes sistemas operativos y diferentes usos. Escoja el que sea más adecuado a su situación.

Usando salidas de control

Además de las clavijas de datos, el puerto paralelo tiene 4 clavijas de salida más. Éstas son las clavijas de apretón de manos STROBE (clavija 1), AF (clavija 14), RESET (clavija 16) y SELECT (clavija 17). Estas salidas dan señales de nivel TTL, pero eléctricamente están construidas de forma diferente y controladas por un registro de control diferente.

Las salidas de control normalmente están construidas como salida de colector abierto con resistencia interna pull-up.

        +5
         |
       4.7 kohm
         |     
         |________  Salida TTL
         |   fuera  
        /         
    ---L apagada      
        \
         |
        Tierra

Este tipo de salidas no puede servir casi nada (aproximadamente 1mA, +5 a través de las resistencias de 4.7K), y sólo pueden enterrar unos 7mA. Este tipo de salida puede controlar entradas TTL perfectamente y posiblemente pueda correr un acoplador óptico o un relé de estado sólido en modo enterrar (depende del dispositivo).

La programación de los registros de control de puerto paralelo se hace escribiendo los valores adecuados al registro de control del enlace de apretón de manos (dirección entrada/salida del puerto paralelo más dos). Puede encontrar más detalles sobre esto en el resumen del registro de puertos paralelos al final de este documento.

Nota: En algunos PCs puede haber implementaciones ligeramente diferentes. Por ejemplo, hace unos años era muy popular el chip UM82C11-C como salidas de control estándar TTL con menor (1.5mA) capacidad de corriente que los tradicionales circuitos de colector abierto con resistencias pull-up.

Leyendo las clavijas de entrada en clavijas de entrada del puerto paralelo

El puerto paralelo de un PC tiene 5 clavijas de entrada. Estas entradas pueden aceptar señales de nivel TTL (0-0.7V = lógica 0, 2.4-5V = lógica 1). Puede conectarles directamente una señal de salida de nivel TTL (recuerde que hay que conectar la toma de tierra de la fuente de la señal a la toma de tierra del puerto paralelo). Puede conectar varios interruptores simples a las entradas conectando el interruptor entre la toma de tierra del puerto paralelo y la clavija de entrada y después añadiendo una resistencia pull-up de 10Kohm de la clavija a +5V. Cuando el interruptor es activado, la clavija pasa a estado lógico 0. Normalmente es una buena idea aislar el PC de la fuente de señal y, en este caso, también puede valer la pena usar un relé o un acoplador óptico (el relé/acoplador óptico es conectado en el sitio del interruptor, de otra forma, funciona igual que un interruptor).

CONSEJO: Puede evitar el uso de una fuente de energía externa usando una de las clavijas de salida del puerto paralelo como una. Así que establezca una de las clavijas de salida del puerto paralelo a estado lógico 1 y conéctela a una resistencia pull-up de 10Kohm en vez de a una fuente dedicada de +5V extra. Para otras ideas sobre cómo obtener los +5V de energía requeridos, eche un vistazo a Cómo dirigir energía del ordenador a sus circuitos y Fuente de energía de 5V simple para circuitos digitales.

Las clavijas de entrada pueden leerse de la dirección base de entrada/salida del puerto LPT + 1.

Las clavijas de entrada pueden leerse de la dirección base de entrada/salida del puerto LPT + 1.

Aquí tienen unas líneas de código para leer del puerto LPT:

Ensamblador

MOV DX,0379H
IN AL,DX
Obtiene el resultado del registro AL

BASIC

N = INP(&H379);
Donde N es el valor numérico que lee

C

in = inportb(0x379);
or
in = inp(0x379);
Donde N son los datos que quiere sacar. El comando de control del puerto de entrada/salida varia de un compilador a otro, puesto que no forma parte de las librerías de C estandarizadas.

Aquí les pongo un ejemplo de un programa de lectura para Linux que lee el estados de las clavijas de entrada del puerto paralelo:


#include 
#include 
#include 
#include 

#define base 0x379           /* dirección entrada/salida a leer */

main(int argc, char **argv)
{
  int value;

  if (ioperm(base,1,1))
    fprintf(stderr, "No se puedo acceder al puerto en %x\n", base), exit(1);

  value = inb(base);
  printf("El valor de lectura del puerto 0x%x es %i \n",base,value);
}

 
/* compilar con la línea de comandos
  gcc -O lpt_read.c -o lpt_read */

El usuario debe tener los privilegios de acceso a los puertos necesarios para que el programa se ejecute, de forma que tiene que ser “root” para poder ejecutar un programa de este tipo y no tener problemas de accesos. Si quiere hacer un programa que se pueda ejecutar por cualquiera, entonces primero tendrá que establecer la propiedad del archivo al “root” (por ejemplo, compilándolo como “root”) y dar permisos a todos los usuarios para ejecutarlo y establecer el programa de forma que siempre se ejecute siempre con los derechos del propietario en vez de los del que lo ejecuta. Puede establecer que el programa se ejecute con los derechos del propietario con el siguiente comando:
chmod +s lpt_read

Circuitos de entrada

Hay varias formas de detectar interruptores externos a través del puerto paralelo de una impresora. Las clavijas de entrada del puerto paralelo toman señale de entrada de nivel TTL (0V a 5V). Puede conectar interruptores a esta entrada con el circuito siguiente.

                      4.7K
         Entrada -------+-^^^^^--- (+5 v)     
                        |
                   interruptor
		         |
         Tierra --------+---------- (gnd)

Este circuito utiliza resistencias (4.7K) de las entradas de estado a +5V y usa interruptores para llevarlas al suelo. Si quiere usar las cinco entradas, construya cinco circuitos para cada clavija. Una desventaja de esto es que usa una fuente de energía externa de +5V. Si tiene clavijas de salida de datos libres puede usarlas como fuente de +5V para este circuito (una salida de datos es suficiente para abastecer varios circuitos de este tipo).

Las entradas TTL al puerto paralelo tienden a flotar alto, así que puede ser que no necesite las resistencias, pero es arriesgarse (el sistema puede no funcionar de forma fiable).

        Entrada  ------+
                       |
                  Interruptor
	               |
        Tierra   ------+

Circuito de ejemplo para un circuito de entrada de 5 canales por puerto paralelo con interruptores. Este circuito usa resistencias pull-up de 3Kohm y resistencias 330 extra “de seguridad” entre el puerto paralelo y el resto del circuito.

Five switches to parallel port circuit

Puede modificar estas ideas de circuitos para otras aplicaciones. Por ejemplo, puede sustituir el interruptor en el circuito por relé de contacto de salida o por un lado de salida de acoplador óptico. De esta forma, puede obtener los señales de forma clara en su PC y mantener el PC aislado de su circuito de control.

Los circuitos siguientes se pueden usar para aislar componentes externos al conectar con el puerto paralelo. Conecte el lado de salida del acoplador óptico (en el lado derecho) al circuito de entrada del puerto paralelo al sitio del interruptor del circuito de más arriba. Si desea el control de ambos el interruptor y la señal externa, conecte la salida del acoplador óptico al interruptor en paralelo. Por favor, asegúrese de colocar el acoplador óptico fuera – conecte el lado que hay que conectar a tierra a la toma de tierra (si lo coloca al revés el acoplador óptico no funcionará).

4N33 optoisolator

                                    fuera +  
                R1    1  ----------- 5    |    
 Dentro+  ----1k------| Opto-     |-----+    
                      | aislante  |          
 Dentro- -------------|           |-+        
                      2  ----------- 4|        
                   CNY 17 o     | 
                   4N25         | 
                               fuera -
                              (conectar a tierra)

El voltaje de entrada que puede servir a la entrada del acoplador óptico puede ir de unos pocos volts hasta 30 volts. El voltaje mínimo al que el circuito empieza a activar la señal del puerto de la impresora varia en función del acoplador óptico (generalmente, a partir de unos pocos volts, lo que es seguro es que una entrada de menos de 1V no funcionará). Tenga cuidado de servir la señal de entrada a la entrada del acoplador óptico a la polaridad adecuada (una polaridad de la señal errónea puede estropear el acoplador óptico).

Enlaces de ejemplo de circuitos de entrada de puerto paralelo

Software de lectura listo para usar

La página de monitorización de puertos paralelos en http://www.epanorama.net/counter.php?url=http://neil.fraser.name/software/lpt/ tiene programas que le permite establecer y monitorizar los estados de las clavijas del puerto paralelo. Este software se encuentra disponible en diferentes versiones para sistemas Windows 98 / ME / NT / 2000 / XP y DOS / Windows 3.1 / 95 / 98 / ME. El software está escrito en los lenguajes de programación Visual Basic y Euphoria y está disponible en forma de código fuente.

La página Zoomkat's "El Cheapo" Parallel Port Contact/Switch Monitor en http://www.epanorama.net/counter.php?url=http://www.geocities.com/zoomkat/status.htm describe como hacer un monitor de contacto/interruptor de puerto paralelo controlado vía Web. El esquema muestra como conectar las clavijas de datos y de estado del puerto paralelo. La página le ofrece un archivo batch y un archivo qbasic que se encuentra en la carpeta CGI-bin de apache además de una copia de qbasic.exe.

Más clavijas de entrada

Si no está contento con sólo cinco clavijas de entrada del puerto paralelo, hay algunos trucos para añadir más.

Si está tratando con interruptores desnudos, lo más sencillo es conectar hasta 4 interruptores entre las clavijas de control (clavijas 1, 14, 16 y 17) y la toma de tierra, programe las salidas de control en alto (teniendo en cuenta las inversiones) y use el registro de feedback de control para leer el estado (teniendo en cuenta las inversiones). Resumiendo, programe las salidas en alto y lea el feedback.

        Cn Salida ------+
                        |
                 Interruptor
		                |
        Tierra ---------+

También podría usar las 8 líneas de datos del puerto paralelo para entrada si tiene un puerto de impresora bidireccional. En teoría, si todo está configurado correctamente, lo único que tendría que hacer es conectar los interruptores a las líneas de datos como más arriba, pero a la práctica, esto no es una buena idea. Para conectar de forma segura los interruptores a las líneas de datos, necesita asegurarse que antes las líneas de salida han sido “tristated” o un acortamiento del interruptor a tierra podría dañar el IC del puerto paralelo. Esto puede ser un problema después de encender/reiniciar donde no se puede estar seguro del modo de operación del puerto de la impresora (normalmente, las clavijas de datos se encuentran por defecto en modo salida).

Una solución práctica es usar resistencias limitadoras de corriente en serie por si acaso y después colocar también unas resistencias pull-up.

                         1K            4.7K
         Dn salida --------^^^^^-----+----^^^^^------ (+5v)
                                     |
                                  Interruptor
                                     |
         Tierra ---------------------+--------------- (Gnd)

Resumen técnico del registro de software de puertos paralelos

La siguiente descripción de puertos es aplicable a los puertos paralelos estándar (SPP).

Offset
Nombre
Leer/Escribir
No. Bit
Propiedades
Base + 0
Puerto de datos
Escribir
Bit 7
Datos 7
Bit 6
Datos 6
Bit 5
Datos 5
Bit 4
Datos 4
Bit 3
Datos 3
Bit 2
Datos 2
Bit 1
Datos 1
Bit 0
Datos 0
El registro de datos es simplemente usado para sacar datos por las líneas de datos (clavijas 2-9) del puerto paralelo. Si su puerto es bidireccional, puede recibir datos en esta dirección.

Offset
Nombre
Leer/Escribir
No. Bit
Propiedades
Base + 1
Puerto de estado
Sólo lectura
Bit 7
Ocupado
Bit 6
En reconocimiento
Bit 5
Sin papel
Bit 4
Select In
Bit 3
Error
Bit 2
IRQ (No)
Bit 1
Reservado
Bit 0
Reservado
El puerto de estado (dirección base +1) es un puerto de sólo lectura. Cualquier dato escrito a este puerto será ignorado. Nótese, por favor, que el Bit 7 (Ocupado) se encuentra activo en entrada baja.

Offset
Nombre
Leer/Escribir
No. Bit
Propiedades
Base + 2
Puerto de control
Leer/escribir
Bit 7
No usado
Bit 6
No usado
Bit 5
Permite puerto bidireccional
Bit 4
Permite IRQ vía línea ACK
Bit 3
Seleccionar Impresora
Bit 2
Inicializar impresora (Reset)
Bit 1
Servir a línea automáticamente
Bit 0
Strobe

El puerto de control (dirección base +2) está pensado como un puerto únicamente de escritura. Cando se conecta una impresora al puerto paralelo, se usan cuatro controles. Éstos son Strobe, Servir a línea, Inicializar y Seleccionar impresora. Todos excepto el inicializar son invertidos.

También puede usar las clavijas de salida en este puerto como clavijas de entrada. El puerto de control tiene que estar establecido a xxxx0100 para poder leer datos, eso significa que todas las clavijas tienen que estar a +5V en el puerto, para que se pueden llevar a la toma de tierra (lógico 0) con su hardware externo. Una resistencia de 4.7K a +5V se puede usar para sacar la clavija en alto, cuando no esté en bajo. Los datos se leen de la misma dirección en la que normalmente escribe los datos.

 
<= entrada    DB25     Cent     Nombre de     Reg
=> salida    clavija  clavija     Señal       Bit     Notas de función
-------------   ------   --------  ---------    -----    -----------------
=>             1       1         -Strobe      C0-      Establecer pulso bajo >0.5 us para enviar
=>             2       2         Data 0       D0       Establecer a los datos menos importantes
=>             3       3         Data 1       D1       ...
=>             4       4         Data 2       D2       ...
=>             5       5         Data 3       D3       ...
=>             6       6         Data 4       D4       ...
=>             7       7         Data 5       D5       ...
=>             8       8         Data 6       D6       ...
=>             9       9         Data 7       D7       Establecer a los datos más importantes

<=            10      10         -Ack         S6+  IRQ Pulso bajo ~ 5 uS, después de aceptar
<=            11      11         +Busy        S7-      Alto para ocupado/fuera de línea/error
<=            12      12         +PaperEnd    S5+      Alto para sin papel
<=            13      13         +SelectIn    S4+      Alto para impresora seleccionada
=>            14      14         -AutoFd      C1-      Establecer bajo para servir una línea automáticamente
<=            15      32         -Error       S3+      Bajo para error/fuera de línea/sin papel
=>            16      31         -Init        C2+      Establecer pulso bajo >50uS para inciar
=>            17      36         -Select      C3-      Establecer bajo en seleccionar impresora
==            18-25   19-30,     Tierra
                        33,17,16

Puerto             R/W  IOAddr  Bits   Función
----               ---  -----   ----   ---------------------
Salida de datos     W   Base+0  D0-D7  8 salidas LS TTL
Entrada de estado   R   Base+1  S3-S7  5 entradas LS TTL
Salida de control   W   Base+2  C0-C3  4 salidas TTL de colector abierto
    "               W   Base+2  C4     interno, permitir IRQ
    "               W   Base+2  C5     interno, “Tristate” datos [PS/2]
Feedback de datos   R   Base+0  D0-D7  normalmente corresponde a Salida de Datos *
Feedback de control R   Base+2  C0-C3  Normalmente corresponde a salida de control *
    "               R   Base+2  C4     interno, permitir lectura de IRQ

* NOTA: Puede ser diferente del estado de salida escrito en algunos casos en que el circuito externa tira de la clavija activamente a un estado diferente del puerto paralelo para conducirlo. Por ejemplo, si las salida está escrita como lógica alta y la clavija es acortada a la toma de tierra (por ejemplo, cuando la clavija está siendo usada como clavija de entrada), la lectura del feedback nos dice que está en estado bajo.

Nótese que en la operación de puertos paralelos bidireccionales diferentes fabricantes implementan sus puertos bidireccionales de formas diferentes.

NNotas sobre la operación de puertos paralelos durante el arranque del ordenador

La operación del puerto paralelo cuando el ordenador se está encendiendo puede variar ligeramente en función de cada ordenador. No he oído nunca que exista una operación exacta estandarizada para la operación de puertos paralelos al iniciar el ordenador.

En el caso más simple, las clavijas de datos del puerto paralelo pueden ser al azar al principio y seguidamente colocarse todas al estado lógico 0. Así es como las cosas funcionaban normalmente en los ordenadores antiguos. Algunos de los ordenadores con sistemas Windows más modernos parece que dejan todas las clavijas del puerto paralelo a estado lógico 1 (+3…5V). En algunos ordenadores, el estado de las clavijas puede cambiar unas cuantas veces durante el proceso de inicialización, lo que significa que si conecta unos LEDs a las clavijas del puerto paralelo, los verá encendiéndose y apagándose intermitentemente. Por ejemplo, muchos ordenadores portátiles acostumbran a enviar los datos del tiempo de encendido a través del puerto paralelo. Durante el proceso de inicialización el código enviado al puerto paralelo puede cambiar varias veces. Normalmente no se puede fiar del estado de las clavijas del puerto paralelo hasta que ha podido escribir un estado definido en ellas.

Al controlar sistemas electrónicos a través del puerto paralelo del PC, lo mejor es seguir la secuencia siguiente:

De esta forma el dispositivo no recibirá ninguna señal de control que usted no diseñó para que recibiera, sin importar qué pase durante el encendido del ordenador.

Notas sobre las diferentes versiones de puertos paralelos

Los primeros puertos paralelos compatibles con PCs eran unidireccionales, permitiendo únicamente la transferencia de 8-bits de datos desde el servidor al periférico. Estos primeros puertos de impresora estandarizados (SPP) implementaban 8 líneas de datos y usaban nueve líneas de apretón de manos, 4 de salida del servidor y 5 de entrada al servidor. Los tres registros de tipo SPP para el control y monitorización de las líneas de apretón de manos y de datos; éstas son el puerto de datos, el puerto de estado y el puerto de control. Los puertos paralelos de tipo SPP son usados mayoritariamente por impresoras, plotters, llaves, etc. Generalmente, todos los puertos paralelos modernos pueden operar en modo SPP. La distancia de cable máxima entre el ordenador y el periférico se veía limitada a únicamente 6 pies.

Más tarde llego el puerto paralelo bidireccional de tipo PS/2 (BPP); este puerto bidireccional simplemente añadió la posibilidad de leer datos de 8-bit del periférico al servidor. Este tipo de puerto paralelo también implementaba los 3 registros usados por el puerto SPP para el control y monitorización de las líneas de datos y de apretón de manos; éstas son el puerto de datos, el puerto de estado y el puerto de control. Además de las operaciones normales, hay un bit extra en el puerto de control que puede establecer todas las clavijas de datos a modo entrada o salida.

El estándar IEEE 1284, “Método de señalización estándar para interfaces periféricas bidireccionales paralelas para ordenadores personales” buscaba corregir los mayores inconvenientes de la estructura original de los puertos paralelos. IEEE 1284 establece estándares para cables, conectores e interfaz eléctrica que garantizan la interoperabilidad entre todos los periféricos paralelos. La configuración especificada asegura que se mantiene la integridad de los datos, incluso a las mayores densidades de datos y a una distancia de hasta 30 pies. Ahora hay dos tipos nuevos de puertos paralelos con más opciones: el puerto paralelo mejorado (EPP) y el puerto de capacidades aumentadas (ECP). EPP y ECP son estándares definidos por las especificaciones IEEE 1284 y Microsoft. Tanto los puertos ECP como los EPP pueden ser operados en los modos bidireccional y SPP; no obstante, la operación en sus modos especiales requiere de periféricos compatibles y de los drivers de software adecuados. Normalmente, EPP se usa para periféricos no-impresora, CD ROM, discos casete, discos duros, adaptadores de red, etc, … mientras que ECP está pensado para la nueva generación de impresoras y escáner. Actualmente, se han desarrollado nuevos productos que suportan una mezcla de ambo protocolos. Con el EPP, el driver de software puede mezclar operaciones de lectura y escritura sin sobrecalentar o requerir un apretón de manos de protocolo. Con el puerto ECP, los cambios en la dirección de los datos deben ser negociados.

La interfaz entrada/salida en los puertos ECP y EPP es ligeramente diferente de los controles de los puertos entrada/salida normales. Se pueden entender como súper puertos SPP. El puerto paralelo EPP implementa dos registros además de los estándar de datos, estado y control. Las salidas son salidas tristeables que permiten que el puerto EPP sea usado como bus de datos para múltiples dispositivos EPP. Toda la transferencia de datos ocurre dentro de un ciclo entrada/salida ISA. Un puerto paralelo ECP nos ofrece dos modos especiales, llamados ciclos de datos y de comandos. En el modo FIFO de datos del puerto paralelo, los datos escritos o DMAed a un FIFO de 16-bytes son automáticamente transferidos al periférico usando el protocolo estándar de puertos paralelos. El modo ECP de puerto paralelo permite la transferencia bidireccional automática de datos dentro del apretón de manos vía el protocolo ECP. Cuando se propuso el protocolo ECP, también se propuso una implementación de registro estándar a través de la especificación ECP de Microsoft. El protocolo ECP está pensado para ser conducido por DMA en vez de por operaciones de entrada/salida explícitas. El protocolo ECP se ve muchas veces en puertos paralelos de la placa madre y en las mejores tarjetas de puerto paralelo que se conectan al bus ISA, pero son mucho menos comunes en tarjetas de puerto paralelo en bus PCI (porque el bus PCI no suporta transferencias DMA de tipo bus ISA).

Muchos puertos paralelos modernos suportan los modos SPP1, BPP, ECO y EPP o, al menos, la mayoría de ellos. En algunos sistemas y tarjetas de interfaz a veces hay opciones para seleccionar el modo de operación (así que evite cualquier problema potencial).

Las operaciones de control entrada/salida más simples he descrito en este documento que no hay beneficio alguno por usar otro modo de operación que no sea el SPP. Normalmente el control de puertos paralelos debería funcionar con rutinas simples entrada/salida directamente para prácticamente todos los puertos. En algunos casos raros, si tiene problemas, pruebe a establecer el puerto a modo SPP, debería estar garantizado que los ejemplos de control de entrada/salida que le he dado funcionen en este modo.

Notas sobre tarjetas de puerto paralelo en bus PCI

No he jugado mucho con tarjetas de puerto paralelo que se conectan al bus PCI, pero he visto casos donde el puerto paralelo que se conecta al bus PCI no funciona correctamente con software legacy, refiriéndome al software que se encarga de controlar directamente el puerto paralelo a nivel de bus entrada/salida. Parece que los puertos paralelos PCI son diferente hardware que los puertos paralelos normales, por lo menos, se colocan en una dirección entrada/salida diferente. El driver del puerto paralelo (viene incluido con la tarjeta o con Windows) hace que la tarjeta del puerto paralelo parezca un puerto paralelo normal frente a las aplicaciones de alto nivel, aunque la operación interna sea diferente que la de los puertos tradiciones. Me han dicho que los sistemas en que había ambos bus ISA y PCI, el rango de la dirección entrada/salida normalmente usado para los puertos paralelos estaba limitado de forma que sólo fuera accesible por el bus ISA, lo que significa que los puertos en el bus PCI tenían que estar en otra dirección entrada/salida (más alta). Hoy en día que el bus ISA ha prácticamente desaparecido de los ordenadores de escritorio, las cosas podrían ser diferentes. Como he visto en http://www.epanorama.net/counter.php?url=http://www.lpt.com/Products/DualPciParallelAdapter/dualpciparalleladapter.htm una tarjeta de puerto paralelo que dice que se configura automáticamente a un dirección entrada/salida disponible (3BC, 378 o 278), evitando la necesidad de reconfigurar los periféricos legacy del puerto paralelo (por ejemplo, discos Zip.). Este tipo de tarjeta puede funcionar con los ejemplos de más arriba. Otras tarjetas parece que pueden funcionar en otras direcciones.

Por ejemplo, la página http://www.epanorama.net/counter.php?url=http://www.tharo.com/nettroub/pci_parallel_adapter.htm parece que muestra algunos detalles del adaptador PCI CyberParallel. El adaptador PCI CyberParallel parece que en el ejemplo se encuentra en las direcciones de entrada/salida 1088-108F y 1080-1083 (direcciones en hex). De acuerdo con otros detalles, podría ser que esta tarjeta funcionara por ella misma de forma parecida a un puerto de impresora normal, pero la dirección de entrada/salida es diferente. Encuentre la dirección de entrada/salida de la tarjeta y después pruebe mis ejemplos de control de puertos paralelos con esta dirección.

La página Web http://www.epanorama.net/counter.php?url=http://www.dta.it/support/manuals/html/dcl/group__addr.html titulada Parallel port address on ISA o PCI bus nos muestra una lista de las direcciones entrada/salida para los distintos tipos de puerto paralelo (se listan tanto direcciones de puertos ISA como PCI):

#define  LPT0   0x3BC 
  Puerto EPP estándar paralelo en la dirección 3BCH. 

#define  LPT1   0x378 
  Puerto EPP estándar paralelo en la dirección 378H. 
 
#define  LPT2   0x278 
  Puerto EPP estándar paralelo en la dirección 278H. 
 
#define  LPT3   0x27C 
  Puerto EPP estándar paralelo en la dirección 27CH. 
 
#define  LPT4   0x26C 
  Puerto EPP estándar paralelo en la dirección 26CH. 
 
#define  LPT5   0x268 
  Puerto EPP estándar paralelo en la dirección 268H. 
 
#define  PCI0   0x9800 
  Puerto EPP estándar paralelo en la dirección 9800H. 
 
#define  PCI1   0xA000 
  Puerto EPP estándar paralelo en la dirección A000H. 
 
#define  PCI2   0xA400 
  Puerto EPP estándar paralelo en la dirección A400H. 
 
#define  PCI3   0xA800 
  Puerto EPP estándar paralelo en la dirección A800H. 

#define  PCI4   0xB000 
  Puerto EPP estándar paralelo en la dirección B000H. 
 
#define  PCI5   0xB400 
  Puerto EPP estándar paralelo en la dirección B400H.

No he comprobado estas direcciones entrada/salida por mi mismo.

En sistemas Windows modernos (Yo lo probé en Windows 2000) puede la dirección entrada/salida del puerto paralelo en el administrador de dispositivos. Primero abra el administrador de dispositivos (inicio – configuración – panel de control – sistema – hardware – administrador de dispositivos). Una vez allí, selecciones el puerto que le interesa en la sección Puertos (COM y LPT). Con el botón derecho del botón se le abrirá un menú en el que debe seleccionar Propiedades. Una vez allí, selecciones Recursos y se le abrirá una ventana como ésta:

Windows device control IO address view

Los detalles en esta imagen son del puerto paralelo integrado en la placa madre de mi PC.

Con suerte, esta información le servirá a alguien como punto de partida para sus experimentos. Si alguien tiene más detalles, estaré encantado de añadirlos.

Notas sobre adaptadores de puertos paralelos por USB

Los adaptadores de puerto paralelo por USB permiten a los usuarios conectar dispositivos de interfaz de puerto paralelo como impresoras a su ordenado a través del puerto USB. A medida que los USB se vuelve más populares, los nuevos ordenadores portátiles se fabrican ya sin puertos paralelos ni/o puertos en serial. Los PCs más antiguos tenían puertos paralelos y no puertos USB, los ordenadores de hoy tienen ambos y los ordenadores de mañana tendrán puertos USB, pero no puertos paralelos.

Los puertos paralelos a través de este tipo de adaptador se ven exactamente igual para programas de alto nivel en sistemas Windows. La implementación a bajo nivel pero, es totalmente diferente, de forma que las operaciones de control de entrada/salida de bajo nivel descritas en este documento no sirven para adaptadores USB de puerto paralelo. Ya se puede olvidar de usar los puertos paralelos por USB para su propio control de hardware. En algunos casos el adaptador USB de impresora paralelo puede ser útil. Con éste, se puede conectar la impresora a su puerto USB y de esta forma conservar el puerto paralelo de su sistema libre para sus propios circuitos.

Los puertos paralelos por USB normalmente están pensados para controlar impresoras y nada más. Cuando se usa un HP Officejet o cualquier otro producto multifunción, el adaptador del puerto paralelo sólo se encarga de la función impresora. No funcionará con la función de fax o de escaneo del producto multifunción, mientras que por las clavijas de salida que hemos comentado en este artículo sí.

Si su ordenador ya es de los que no tienen ningún puerto paralelo y todo lo que puede usar son USB, seguramente debería considerar hacer la entrada/salida que necesita con una tarjeta de entrada/salida industrial que se conecta al puerto USB. Este tipo de tarjetas se acostumbran a distribuir con su propio software de control y sus propias librerías de programación a usar para controlarlos.

Otros documentos que vale la pena consultar


Tomi Engdahl <then@delta.hut.fi>