Build the Xanadu Zapper!
Build the Xanadu Zapper!
by
Scott Coleman
Xanadu Consulting
Internet: coleman@f69.n233.z1.fidonet.org
FIDOnet: 1:233/69.0 (Xanadu BBS 217/384-2127)
Copyright 1990 Scott Coleman. All Rights Reserved.
The following is a description of a computer-assisted semi-
universal infrared learning remote control project. It consists
of a small, inexpensive and easy to build hardware device (the
Zapper) which contains both an IR (infrared)
detector/demodulator and an IR emitter. The Zapper attaches to a
personal computer via a TTL-level parallel input/output port and
is controlled by software running on the PC. The Zapper will
allow your personal computer to learn the control signals sent
out by many IR remote control devices and duplicate them under
program control.
The information contained in this document and in the
accompanying schematic diagram, ZAPSCHEM.GIF, was synthesized
from various sources, including Usenet, magazine articles, and
component data sheets. It is not a "complete" project in the
sense that it does not include a step-by-step cookbook recipe for
constructing an exact replica of my Xanadu Zapper prototype.
Realizing that not everyone in the universe owns an IBM AT clone,
I have opted instead for a more general description of the
hardware, software, and interfacing considerations. My hope is
that this document will serve as a good starting point for your
own experimentation in the realm of IR control. Feel free to
distribute this document to anyone who might be interested. If
you do distribute it to others, I ask that you do NOT charge a
fee of any kind.
For more detailed information on how IR remote controls
work, I refer you to two excellent articles on the subject
written by Steve Ciarcia which appeared in Byte magazine
("Ciarcia's Circuit Cellar," February and March, 1987).
The uses for the Xanadu Zapper are limited only by your
imagination and your IR equipped devices. My purpose in building
the Zapper was to allow a computer to control several different
VCRs via their IR control links, allowing easy frame-by-frame
analysis of research subjects recorded on videotape. Because of
its semi-universal nature, however, the Zapper is by no means
limited to this task. Among other things, the Zapper can be used
to:
o Control a VCR for use in automatically taping computer
graphics output.
o Control two VCRs for use in editing and dubbing between
decks.
o Control a CD player for a computer-controlled jukebox.
o Work in conjunction with an IR-equipped cable TV
descrambling box to record multiple programs on different
channels while you're away.
o Use the hand-held remote control from your TV set to
control your computer (which in turn can control some other
device).
o Anything else you can dream up.
I refer to the Xanadu Zapper as "semi-universal" because it
will work only with remote control devices which operate at a
40kHz IR carrier frequency. Fortunately, quite a few IR equipped
devices fall into this category, among them Sony video products
(e.g. KV1397R TV, SL-HF900 VCR), JVC video products (HR-S5000U
VCR) and Panasonic Industrial video (AG-1960 VCR).
For those of you who are unfamiliar with IR communication
and IR remote controls, the next section is a brief overview of
what we're trying to accomplish. The more advanced readers may
wish to skip ahead to the circuit description section. For more
detailed information, I refer you to the articles mentioned on
the first page of this document.
A Brief Overview of IR Communication
Many of today's consumer electronic devices (e.g. TVs, VCRs,
CD players, etc.) are equipped with small hand-held remote
controls. These remotes are nothing more than small wireless
keypads which, when a button on the remote is pressed, send a
coded signal to a receiver unit inside the VCR. The signal may be
ultrasonic, radio frequency, or IR light. IR remotes are very
popular because of their limited range (line-of-sight only) which
reduces interference with other remote controlled devices (e.g.
your neighbor's TV set). Since this project involves duplication
of IR control signals, we'll limit our discussion to remotes of
this type.
IR remotes generate a stream of IR light pulses which is
amplitude modulated to produce the encoded signal. The VCR
contains circuitry which will detect and demodulate this signal
to recover the original signal specifying the command to be
performed (e.g. PLAY or POWER ON). The specifics of how the
signals are encoded varies from manufacturer to manufacturer, and
sometimes from model to model. This variation is the reason why
(with few exceptions) the remote from your VCR doesn't work with
your TV and vice versa. Fortunately for us, the computer doesn't
need to be able to "understand" the IR signals in order to be
able to learn and reproduce them, so the variations in encoding
schemes won't affect us.
Circuit Description
The circuit is very simple. Even I, a software type with no
electrical engineering background, was able to build it and get
it working. It requires only a few components (see parts list at
the end of this document) and should cost less than $30. Almost
everything you need to build the Zapper can be found at your
local Radio Shack. (Note that I am not a Tandy employee nor
affiliated with them in any way, but I do live in an area which
is sorely lacking in retail outlets which stock electronic parts.
For me, it is either RS or mail order.) The circuit consists of
two main sections: an IR receiver and an IR transmitter. The
receiver portion is made up of precisely one component: a Sharp-
made GP1U52X IR detector module sold by Radio Shack. In a small
rectangular package less than one cubic inch in size Sharp has
stuffed an IR detector, an amplifier, a limiter, a band-pass
filter, a demodulator, an integrator, and a comparator. Hook it
up to a 5V power source, and it produces a TTL-level demodulated
version of the IR signals it detects. It also rejects any IR
source not modulated at 40kHz to reduce interference from ambient
light or other sources. The output of the detector module can be
fed directly into a binary input line on a computer's parallel
input port. The computer "learns" the IR signals by sampling this
input line and storing the serial data as it comes in through the
port.
The transmitter is only slightly more complicated than the
receiver. Borrowing from the circuit provided on the data sheet
that RS includes with the IR detector module, I built a 40kHz
oscillator around a 555 timer chip. The output of the circuit
drives an IR LED, flashing it on and off at approximately 40kHz
(the exact frequency is adjustable via a trimmer resistor),
producing the IR carrier signal. The carrier is modulated by
connecting a binary output line from a computer's parallel port
to the reset input on the 555 chip. Raising the output line to a
logic 1 TTL level enables the carrier generation; lowering the
line to logic 0 disables it.
Interfacing Considerations
Your computer must be equipped with a TTL-level parallel I/O
port in order to control the Zapper. Back in the early days of
personal computing, many micros came with a general purpose
parallel I/O port as standard equipment. These days, however,
computer manufacturers seem to be moving away from this sort of
thing, so you'll more than likely have to make do with whatever
I/O capability you have. Machines which use digital switch type
joysticks, such as the Atari 800 or the Commodore 64, may be able
to control the Zapper via a joystick port. Typically, the
joystick port is read through a PIA chip which can be programmed
to act either as an input or as an output port. Note: this does
not apply to systems which use analog type joysticks, such as the
IBM PC or the Apple II.
Another workable solution is to use a Centronics-type
parallel printer port. These ports have both input and output
lines which operate at TTL signal levels. On machines which allow
two or more printer ports to coexist, it is a good idea to
install a second printer port so that you won't have to swap
cables every time you want to use the Zapper or the printer.
A third alternative is an add-on parallel interface board.
These are often designed specifically for use in real-world
interfacing/control or in data acquisition applications, and
generally have 16 or more binary inputs/outputs, and possibly
some analog inputs/outputs as well. These tend to be expensive,
however, and are definitely overkill for the Zapper project's I/O
requirements.
With the addition of the appropriate line level conversion
circuitry, it would also be possible to use a serial port instead
of a parallel port. This complicates the power supply
requirements, however, as most commercially available line driver
chips require both +12V and -12V in addition to +5V.
Once you have the circuit assembled (see next section),
you'll need to select one input line and one output line for use
by the Zapper. Connect the output line from the port to the point
labeled IREN in the schematic, and connect the input line on the
port to the point labeled IRDO on the schematic.
Building the Circuit
In addition to the basic circuit, you'll need a power
supply, a project case, and some means for connecting the Zapper
to the computer (as outlined above). Since the details of these
will vary from situation to situation, I'll be purposely vague on
these points and concentrate most of my attention on the basic
circuitry. The examples I will give pertain to my own prototype,
which was designed to work with an IBM AT clone's parallel
printer port. While the details will differ for other types of
computers, the general principles will apply equally well to all.
First, select some sort of power supply. I happened to have
one of those black box 9VDC transformer power supplies lying
around, so I used that in conjunction with a 7805 regulator chip
as my +5VDC power source. This may not be the best choice, but it
seems to do the job. Of course, you can easily construct a power
supply from a transformer, rectifier, some filter capacitors, and
the 5V regulator chip, but you'll need a case big enough so that
everything will fit. Once you've decided upon a power supply, you
can decide just how much circuit board real estate you'll need to
accommodate all the components. For my prototype, I designed a
printed circuit board (using the "do it yourself" PC board kit
available at - you guessed it - Radio Shack), but this isn't
necessary; a perfboard will do just fine. Radio Shack sells
several project case + perfboard combinations. Since I used an
external power supply, everything fit comfortably onto a 2" x 3"
circuit board.
Tuning the Circuit
The only potentially difficult part of the assembly process
is tuning the circuit so that it flashes the IR LED at 40kHz. If
you have an oscilloscope or a frequency counter handy, this
should be a piece of cake. If you don't have access to either of
these, I'm afraid you're in for a period of trial and error
experimentation. Since I don't have either an oscilloscope or a
frequency counter at home, I was forced to do it the hard way.
Here's the procedure I used:
Using the standard formulas for calculating the oscillation
frequency of a 555 timer in astable multivibrator mode, I
determined that R2 (the trim pot) needed to be set to
approximately 37797.8 ohms in order to achieve an oscillation
frequency of 40kHz. I mocked up the circuit on a solderless
breadboard, and connected it to the computer. I removed R2 from
the circuit, and, using an ohmmeter, I set R2 as close to
37.7978K as I could get it, then replaced it back in the
breadboarded circuit. I then wrote a program (a simplified
version of that described in the software section below) which
sampled the output of the IR detector module at about 100kHz,
stored the sampled data in memory, and then played the signal
back by toggling the IR enable line to the Zapper. I took a
remote control which I knew operated with a 40kHz carrier (in
this case, for a Sony VCR), aimed the remote at the IR detector
module, and pressed the power button on the remote. I then
started the sampling process. Once the IR signal from the remote
had been stored in memory, I aimed the IR LED from the
breadboarded Zapper in the general direction of the VCR and
repeatedly played the signal back, adjusting the trim pot until
the signal from the Zapper was turning the power to the VCR on
and off. Because I had pre-set the trim pot to the approximate
value necessary, I only had to adjust the trim pot slightly to
get the Zapper working.
Clearly, the above procedure can require a lot of time,
patience, and a little bit of luck. There are many variables to
keep track of: the carrier frequency emitted by the remote you're
using (if it's not 40kHz it won't work); the distance from the IR
LED on the Zapper to the detector in the VCR (too far away and
the VCR will "see" nothing, too close and the VCR will get a
distorted signal); and, of course, proper wiring of the circuit.
In most cases, your time would be better spent in hunting down an
oscilloscope or frequency counter to borrow for a few minutes
than to go through the trial and error procedure I have outlined
above. I leave the choice to you.
Once your circuit is properly tuned, you're ready to
assemble it permanently on its circuit board and install it in
its case. When laying out the components, keep the following in
mind:
o The IR LED must project out through the case so that its
light can be seen by the VCR.
o A "window" must be cut in the case directly above where
the IR detector module is to be mounted, so that IR light
from remotes can be sampled. This can be as simple as an
uncovered rectangular hole, or the hole can be covered with
a small piece of smoked plexiglas to keep out the dust and
ambient light while still allowing IR light to enter the
case.
o Jacks for the computer and power supply must be
accommodated.
o You'll probably want to mount a power switch somewhere on
the case, as well.
My prototype has the IR LED projecting through the front, a DB25
connector on the right hand side (which connects to the computer
via a detachable cable), and a power jack on the back. On the top
are the power switch and the window (plain old hole version) for
the IR detector.
After you've put everything together, you're ready to start
working on the driver software.
Software Considerations
In an effort to keep this document as general as possible, I
have not included any actual code. Instead, I am including enough
information to allow interested hackers to roll their own,
customized to their individual needs and goals.
I wrote a program called ER ("Expensive Remote") for use
with my Xanadu Zapper prototype. It is a mouse-driven, graphics-
based program which samples IR signals, displays them graphically
on the screen, stores them, and reproduces them. Adding the
capability to plot a graph of the incoming IR signal served two
functions: it allowed me to easily edit the stored signals (see
below), and it allowed visual verification that the receiver
portion of my circuit was functioning properly. Minimally, the
program must perform three functions: data sampling, data
reproduction, and data storage. We'll examine each of these in
turn.
In order to be able to recreate the IR signals, the computer
must first be able to "see" what they look like. This is done by
sampling the status of the IR detector module at regular
intervals and at an appropriate frequency. I sampled at
approximately 100kHz, which is more than twice the maximum
possible signal frequency of 40kHz. This is higher than
necessary but turned out to be quite convenient in my
circumstances.
The actual sampling procedure is straightforward. Each
sample consists of one port input operation, one memory store,
and associated housekeeping (bumping a pointer, decrementing a
count). The following pseudocode outlines the sampling procedure
which will sample the output of the IR detector at regular
intervals and store the data into byte array P:
for count = 1 to num_samples do {
input byte from port
save byte to memory location pointed to by P
increment P to point to next address
wait /* make sure samples occur at precise intervals */
}
Sending a signal to the VCR is equally straightforward - the
sampling process is simply reversed. Using the same data buffer
in which the bits representing the sampled IR signal are stored,
the software sequentially reads a byte from the buffer and sends
it out the parallel port, making certain that the significant bit
in the sampled data "lines up" with the bit in the output port
which controls the Zapper's IR emitter circuit (e.g. in my
prototype, the input line corresponds to bit 7 of the input port,
but bit 0 of the output port controls my IR emitter; thus, I have
to shift my input data to the right before sending it out again).
The following pseudocode accomplishes the send:
set count = number of bytes in output buffer
set P = address of first byte in output buffer
for count = 1 to #bytes_to_send do {
fetch byte pointed to by P
increment pointer P
output byte through port
wait /* make sure output data is evenly spaced */
}
If the sending is clocked at the same frequency at which the
sampling occurred, a reasonably accurate reproduction of the
original IR signal will be produced.
The best sampling/sending method involves the use of
precision timing hardware. For example, the IBM AT has a
programmable timer chip built onto the motherboard which is
capable of generating an interrupt to the CPU at user-
programmable time intervals. By programming the timer chip to
generate interrupts at the desired frequency, and providing a
suitable interrupt service routine, the input line can be sampled
at precise intervals with very little programming effort, and the
sampled signals can be sent out the port at exactly the same
rate. Other systems have similar methods for generating
interrupts at precise intervals. If such precision timing
hardware is not available on your PC, the task becomes somewhat
more difficult. In this case, sampling the data will involve some
tight assembly level coding which takes into account the
processor's clock speed, the effects of system interrupts, cycles
stolen by memory refresh, DMA, other system components (e.g.
graphics coprocessors), etc. Of course, therein lies the real
fun!
Storage Requirements and Data Compression.
On most microcomputers, it is impossible to input only a
single bit from an I/O port. More often, the processor will
fetch data from the port 8, 16, or 32 bits at a time. Thus, each
sample of the IR detector's output will consist of one
significant bit and at least 7 "don't care" bits. In order to
sample as quickly as possible, the sampling code will likely have
to store the entire byte input from the port as a unit. Although
it is certainly possible (at least on some of the faster
machines) to perform all the bit twiddling necessary to get the
single bit we're after and store it efficiently in the time
between samples, it's not really necessary. Since the IR signals
are generally of short duration, 0.5 second of sampling is
usually enough to capture more than one complete message. At 1
byte per sample and 100000 samples per second, that's about 50K
bytes. The extraction of the significant bit can be done later,
which greatly simplifies the sampling code.
The problem with this scheme comes in when one wishes to
store the signals (say in a disk file) for later recall and use.
At 50K per IR signal and each remote capable of producing 30-60
different signals, the storage requirements add up fast.
Fortunately, 7 of every 8 bits is garbage (assuming 8-bit port
I/O), and can be discarded. The remaining bits can be packed
together, resulting in an 8-fold reduction in storage
requirements. Of course, either the signal data will need to be
expanded again before the send routine can make use of it, or the
send routine outlined above would have to be modified to make use
of the new data format.
Further reduction in storage requirements may be realized by
judicious editing of the stored IR signals. If you sample an IR
signal for 0.5 seconds and plot a graph of the signal over time,
you'll see that the signal does not appear just once but is
instead repeated several times throughout the sampling period. In
order to reproduce the signal, only one complete message is
required as your software can repeat it as many times as
necessary. In my Expensive Remote program, I added just this sort
of data plotting and editing capability which allows me to chop
out all the excess signal (by pointing and clicking with a mouse)
and save only the required minimum signal. The additional savings
realized by cutting out the excess signal data will vary
depending upon how long each individual message from the remote
lasts.
Closing Remarks
Well, there you have it. I have tried very hard to be clear,
concise, and complete in my description of the Xanadu Zapper; I
hope that I have succeeded. I welcome your comments, corrections,
and (constructive) criticisms, as well as any unique and
interesting uses you may come up with for the Zapper. Should you
wish to get in touch with me, my email addresses appear at the
beginning of this report. I hope you have as much fun building
and using the Zapper as I did. Good luck, and happy zapping!
Parts List
C1 - 470 pF capacitor
C2 - 0.01 uF capacitor
LED1 - SEP8703-1 IR LED (RS 276-143; the emitter from the 276-142
emitter-detector pair also seems to work)
R1 - 1K resistor, 1/4 watt
R2 - 50K multi-turn trimmer resistor (note: a multi-turn trimmer
is recommended to make tuning the circuit easier.)
R3 - 150 ohm resistor, 1/4 watt
GP1U52X IR detector module (RS 276-137)
Miscellaneous (perfboard, project case, power supply, mounting
hardware, connectors, cable to computer, etc.)
Comments
Post a Comment