| .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 | |