QuarterArcade Coin-Op Tech Net

Introduction

If you are not familiar with the Fluke 9010A, it is a micro-system
troubleshooter. The 9010A, along with an associated microprocessor pod, allows
the user to test boards. This is done by replacing the CPU with the pod,
allowing the Fluke 9010A to control the Unit Under Test (UUT).

One of the benefits of using the 9010A, is that you can create
scripting test suites. All Fluke 9010A Troubleshooters have a
microcassette tape system. However, this requires that you manually
key in programs -- a long and error-prone process.

Luckily, Fluke released the "-001" option (marked on the bottom of the
base unit) that has an RS-232 serial port. This allows yout to author
programs off-line, compile them, and then download your program to the
base unit.

The original RKSIC.EXE software is still available today. However, it is
a DOS program, and while it works, it is a little clunky. For example,
your program names must adhere to the DOS 8.3 file format. You must also
keep all of your scripts in one directory. This makes it somewhat hard to keep
all of your scripts organized. This was the impetus of creating
the Fluke Integrated Development Environment (FIDE) program.

Using the Fluke 9010A

Below is a picture of a typical setup. It's from Fluke's original documentation.

The operator can use the base unit (the large unit with the display) to
issue commands to the pod and therefore the UUT (unit under test). While
a logic probe and scope can identify a lot of possible problems,
there are some things that are a hard to test with those tools (validated
that ROMs are good, verifying RAM, and so on). By giving the user control
over the microprocessor, and some built-in routines to do these tests,
repair time can be cut down dramatically. Note that using a 9010A does
not replace a scope, DMM, or logic probe. And if you're not familiar with
those tools, you might not be ready for a 9010A. If you're looking for
a fix-it-quick tool, this is not it. There is a lot "homework" required
to be able to effectively use a 9010A.

How it compares to a CAT Box

A Fluke 9010A is similar to a CAT box, but it allows you to do a lot more.
A CAT box is specifically designed for Atari systems, and documentation
provided is sometimes geared towards CAT box usage. But the CAT box doesn't
provide the capability to build automated test scripts, doesn't have
built-in utility tests, and it's difficult (although I guess not impossible)
to use it on non-Atari boards.

Available Options

There are a few options that come with the 9010A. If you are considering purchasing
one, be sure to check for what is included. These options are:

By far the most important option to consider is the RS-232/serial port option.
With that option you can make use of programs like FIDE to communicate to the
9010A. Developing scriptable programs without being able to create the scripts
off-line is nearly impossible.

The -003 clock module option is a somewhat advanced option, but worth looking
at. The actual clock module itself is hard to come by. You're probably better
off finding a probe to begin with, as the probe can be used in a very similar
manner.

Pods

Pods are necessary to interface with your UUT. For example, let's say that
you have an Atari Centipede as your Unit Under Test (UUT). You'd need
a 6502 Pod because that is the microprocessor used in that game. Unfortunately
this means that you're going to need to acquire several pods, and
(again, unfortunately) these pods can be expensive. Some cost nearly as
much as a base unit. Keep this in mind when you buy. Try to purchase
a base unit with a common pod that you might need, like the 6502 or
Z80 pod.

Type of tests you can run

So what about these tests that you can run? Here is a brief run down
of the available tests.

BUS

Tests for the ability to drive the data, address, and control
lines. Identify failures like a bad buffer chip.

ROM

Allows you to test ROMs in circuit. The 9010A scans the address
space (you have to provide an address range to test) and computes
a mathematical "signature" much like a CRC. Unfortunately, it's not
a CRC or other common calculation. This means that you'll need to have
a working board with a known good set of ROMs in order to test. Additionally
the ROM signatures will be different for different ROM versions since
it's based on the actual data in the ROM. Finally, you'll have to deduce
or find out the memory map to the chip level to make this completely
effective. Luckily, it's not all that hard to do. Some times reading
the schematic or associated manual information will give you the memory
map for all of the program memory. You can use the size of the ROM to
deduce which chips are located at which address. MAME driver information
also contains a lot of information about the memory maps, so you
can check there as well.

RAM

The RAM Short test and the RAM Long test perform a series of
read and writes to the address range you specify. Again, you have to know
what address ranges to test. Some RAMs can't be easily tested. For example
you might be able to write to a color pallete entry RAM, but you can't
read from it. Still, this is one of the most useful tests that your
9010A can do for you and something that you'd have a hard time
debugging with a scope, DMM, or probe.

I/O

Not too different than the bus test, except the control lines are tested.
Specific to each pod.

These built in tests can locate a lot of the errors that you'll run
into. However, in many cases you'll want even more control, either manually
or programmatically. The base unit also allows you commands like READ, WRITE,
and a host of address and data manipulation commands.

Authoring Scripts

If you have a base unit with the RS-232 option, you can connect it to your
computer. In order to do so, you'll need to build a serial cable, or purchase
a null-modem cable. You'll want a DB9 female to DB25 female cable. Several
places sell these online for cheap. The back of the 9010A, where the serial
cable plugs into the unit, has a set of switches for the base unit's serial
port. You'll want to make sure that these settings match your computer.

You'll also need the compiler program and RKSIC program, or you can use
the FIDE program that replaces these legacy DOS
programs.

Programming is line-based and resembles assembly code (although it is a lot
more readable). All of the commands that are available via the keyboard
are available in the scripting language, although the syntax may be slightly
different.

Keep in mind that scripts don't have to be overly complicated. For example,
if you've spent some time figuring out that memory locations 0000-03FF are
RAM for a board that you've been working on, why not make a simple script
that tests that RAM for you. When you return to another board like that in
three months, you'll just need to run that script versus figuring out what
address space you need to test.