| .oO Phrack 50 Oo. |
|
|
| Volume Seven, Issue Fifty |
|
|
| 11 of 16 |
|
|
| |
| H A R D W A R E I N T E R F A C I N G F O R T H E |
| L I N U X O P E R A T I N G S Y S T E M |
|
|
| By The Professor <professr@hackerz.org> |
|
|
| Computer control of real world devices has been an out of reach fantasy for |
| most people. In the past, it has rarely been seen outside the R&D labs of |
| hardware design companies, universities, and a few dedicated hobbyist's |
| basements. It takes not only a skilled programmer, but also a person that can |
| design and build small circuits. |
|
|
| In this article, I will show you how to use a standard IBM/PC parallel |
| printer port to control devices, such as bells, relays, and lights. I will |
| also show you how to take input from devices such as DTMF decoder IC's, analog |
| to digital converters, and switches. |
|
|
| To access the I/O port, the compiled program must be either executed by root |
| or be suid root. This could be a potential system security hazard so be |
| warned. In order to grant permissions to the port, one must use the function |
| ioperm(). |
|
|
| Syntax (also see the man page): |
|
|
| #include <unistd.h> |
| ioperm(BASE_ADDRESS,NUM,PERMISSION_BIT); |
|
|
| The first parameter is the port number to set permissions of. |
| The second parameter is the number of consecutive ports to set permissions of. |
| (i.e. if num==3, BASE_ADDRESS, BASE_ADDRESS+1, and BASE_ADDRESS+2 are set). |
| The third parameter is 1 to give the program permissions or 0 to remove them. |
|
|
| Sending and receiving data via the port is done with the commands, inb() and |
| outb(). |
|
|
| Syntax: |
|
|
| #include <asm/io.h> |
| value=inb(address); (address can be BASE_ADDRESS+1 or BASE_ADDRESS+2) |
| outb(value,BASE_ADDRESS); |
|
|
|
|
| O U T P U T |
|
|
| Making individual output data lines of a parallel printer port "turn on" is as |
| simple as selecting them with a corresponding binary value. Pin 2 (D0) is the |
| least significant bit and pin 9 (D7) is the most significant bit. If you |
| wanted bits 0, 2, 3, 4, and 6 to "turn on" or go high (+5v) while leaving 1, |
| 5, and 7 low (ground) you would first convert the binary value to decimal and |
| then send that value to the port. (actually, there is no reason why you can't |
| just send the binary value to the port) |
|
|
| D7 D6 D5 D4 D3 D2 D1 D0 |
| 0 1 0 1 1 1 0 1 == 1011101 == 93 |
|
|
| outb(93,BASE_ADDRESS); |
|
|
| If you want all lines low or "off", you send a 0. |
| If you want them all high or "on", you send 255. |
|
|
| Controlling the status of the individual bits of the I/O port is a simple |
| way of controlling solid state relays, optocouplers, LED's and so on. You |
| could very easily and very safely control a high wattage lighting system in |
| this manner. (assuming you are using solid state relays with back EMF |
| protection). This could/would be good for closet cultivators experimenting |
| with the horticulture of cannabis sativa or any other plant. Have you ever |
| wanted things such as lights and irrigation systems to come on or turn off at |
| certain times? That's what your crontab file is for! The possibilities are |
| endless. |
|
|
|
|
| I N P U T |
|
|
| Standard IBM/PC parallel printer ports have nine control lines capable of |
| inputting real world data. Each printer port has three address locations. The |
| base address is used to transmit data. The next address can input five data |
| bits, using pins 11, 10, 12, 13, and 15 (referred to as BASE_ADDRESS+1 I7 |
| through I3), and the third port address can input or output a nibble of |
| information using pins 17, 16, 14, and 1 (referred to as BASE_ADDRESS+2 I3 |
| through I0). The third port address pins must be set HIGH so we can read from |
| BASE_ADDRESS+2. I'll show you how in the example. |
|
|
| The inputs are all active LOW, meaning your device must short them to ground |
| to create a signal (switch, analog to digital converter, DTMF decoder, etc). |
| This is not a problem, as most devices already do this. The ones that don't, |
| just use an inverter. |
|
|
| The simplest method of inputting eight data bits is to read the high nibble |
| from the (BASE_ADDRESS+1) and the low nibble from the (BASE_ADDRESS+2). These |
| two nibbles can be logically ORed together to form a data byte. Some of the |
| data bits are hard-wired on the printer card for active HIGH operation. To |
| get around this, I use four sections of a 7404 hex inverter to re-invert the |
| inverted data lines. |
|
|
| I7 I6 I5 I4 I3 I2 I1 I0 BASE_ADDRESS+1 INPUT LINES |
| 11 10 12 13 15 -- -- -- PIN NUMBER (-- = NOT USED) |
|
|
| I7 I6 I5 I4 I3 I2 I1 I0 BASE_ADDRESS+2 INPUT LINES |
| -- -- -- -- 17 16 14 1 PIN NUMBER (-- = NOT USED) |
|
|
| Notice both I3's of both ports are used. Pin 15 (ERROR) is the 9th input |
| of a standard IBM/PC parallel printer port. No offense to this pin, but it's |
| a pain in the ass to use and I only use it when I *have* to. Through |
| software, I disregard it. |
|
|
| Check out this example: |
|
|
| /* next line sets all open collector output pins HIGH |
| so we can read from BASE_ADDRESS+2) */ |
| outb(inb(BASE_ADDRESS+2) || 15 , BASE_ADDRESS+2); |
| High_Nibble = inb(BASE_ADDRESS+1); |
| Low_Nibble = inb(BASE_ADDRESS+2); |
| High_Nibble = High_Nibble & 0xF0; /* 0xF0 = 11110000 */ |
| Low_Nibble = Low_Nibble & 0x0F; /* 0x0F = 00001111 */ |
| Data_Byte = High_Nibble | Low_Nibble; |
|
|
| Pretty simple, eh? This means you can use I7 through I4 in BASE_ADDRESS+1 |
| and I3 through I0 in BASE_ADDRESS+2 to give you 8 bits of data input. |
|
|
| All of the data lines must use a pull up resistor. This includes the |
| hard-wired active HIGH pins *after* the 7404 inverter. This lets any device |
| produce both a high and low logic signal. Pull up resistors simply pull all |
| the data lines high so software sees all 0's unless you short a pin to ground. |
| (Remember these are all active LOW inputs -ground means 1) |
|
|
| Pins 14, 17, 1, and 11 are all hard-wired for active HIGH operation. These |
| are the pins that are signaled through the 7404 inverter IC (which makes them |
| just like the rest of the pins for ease of use). |
|
|
| NOTES: |
|
|
| *** When compiling programs using these routines, use the -O2 optimize flag, |
| or else you'll have some headaches. |
|
|
| Port 888 is the 1st parallel printer port (LPT1) |
|
|
| I am not responsible for your mistakes. If you plug 120vAC directly into |
| your parallel port, I guarantee you'll destroy your computer. Use optically |
| isolated solid state relays to switch high current. |
|
|
| For any more info regarding I/O port programming, schematics to some fun |
| projects, or to send a complaint, e-mail professr@hackerz.org |
|
|
| If you don't like my code, keep in mind that I design hardware for a living. |
| I am not a programmer, nor have I ever claimed to be one. My programs are |
| elegant on occasion, but mostly just get the job done without actually doing |
| it the best way. |
|
|
| If you want schematics showing how to hook up the 7404 to the port, mail me. |
|
|
| I have some interesting things there regarding circuit design. One of my |
| favorites is a software package called "PADS" Personal Automated Design |
| Software. It is a CAD package for schematics and PCBoard Design. The copy |
| on my web page is a public domain demo. This demo is fully functional in |
| every way. It only limits you to something like 20 IC's, 300 tie points, etc. |
| I usually do not go over these limits. |
|
|
| Maybe this article will replace the IO-Port [mini] How-To 'cause that is only |
| about 24 lines of text. |
|
|
| E X A M P L E S |
| A N D |
| D I A G R A M |
|
|
| /* simple program to send data via parallel port */ |
|
|
| #include <unistd.h> |
| #include <asm/io.h> |
| #define BASE_ADDRESS 888 /* 1st Parallel Port */ |
|
|
| main() { |
| int port_data=0; |
| int Data_Byte=255; |
| ioperm(BASE_ADDRESS,3,1); /* set permission on port */ |
| outb(Data_Byte,BASE_ADDRESS); |
| printf("Sent 255 to port %d to turn all pins HIGH\n",BASE_ADDRESS); |
| ioperm(BASE_ADDRESS,3,0); /* take away port permission */ |
| return(0); |
| } |
| /* end of simple program to send data via parallel port */ |
| /****************************************************************************/ |
| /* simple program to take in 8 bit input via parallel port */ |
|
|
| #include <unistd.h> |
| #include <asm/io.h> |
| #define BASE_ADDRESS 888 /* 1st Parallel Port */ |
|
|
| main() { |
| int port_data=0; |
| int High_Nibble, Low_Nibble, Data_Byte; |
| ioperm(BASE_ADDRESS,3,1); /* set permission on port */ |
| outb(inb(BASE_ADDRESS+2) || 15 , BASE_ADDRESS+2); |
| High_Nibble = inb(BASE_ADDRESS+1); |
| Low_Nibble = inb(BASE_ADDRESS+2); |
| High_Nibble = High_Nibble & 0xF0; /* 0xF0 = 11110000 */ |
| Low_Nibble = Low_Nibble & 0x0F; /* 0x0F = 00001111 */ |
| Data_Byte = High_Nibble | Low_Nibble; |
| printf("LN=%d HN=%d DB=%d\n",Low_Nibble,High_Nibble,Data_Byte); |
| ioperm(BASE_ADDRESS,3,0); /* take away port permission */ |
| return(0); |
| } |
| /* end of simple program to take in 8 bit input via parallel port */ |
| /****************************************************************************/ |
| I I I I I |
| 0 6 7 5 4 |
|
|
| P |
| A |
| _ P |
| S E S |
| T R E |
| R _ B | L |
| O A U E E |
| B D D D D D D D D C S N C |
| E 0 1 2 3 4 5 6 7 K Y D T |
| _____________________________________ |
| 1 (o o o o o o o o o o o o o) 13 |
| 14 \ o o o o o o o o o o o o/ 25 |
| `---------------------------------' |
| _ _ | PINS 18 | |
| A E I S |<----THROUGH 25---->| |
| U R N E | GROUND | |
| T R I L |
| O O T | |
| | R I |
| F N |
| E P |
| E U |
| D * T ** ERROR LINE IS NOT USED AS I3 |
| * (DISREGARDED VIA SOFTWARE) |
| I I I I |
| 1 3 2 3 |
|
|
| /******************** End of my little text file / how-to *******************/ |
|
|
| EOF |
|
|
