Memory & the Card Cage

Why memory is the story here

On the HERO 1 and HERO Jr, memory was a fixed quantity: a few kilobytes of RAM soldered to a single board, a behaviour ROM, and that was the ceiling. On the HERO 2000 it is the opposite — memory is the thing the machine is built to grow. The robot ships with a modest base of read/write memory and a large firmware ROM, and it sits on a passive backplane — a card cage — into which memory and controller cards plug the way expansion cards plug into a desktop computer’s motherboard (HERO 2000 spec sheet, hero.dsavage.net; theoldrobots.com; selectric.org). Two numbers carry the headline. The first is the 576 KB ceiling that the read/write memory can reach through optional cards. The second is that the 64 KB of ROM holds a full BASIC, not just a boot monitor. This volume takes the memory subsystem and the card cage together, because on a card-cage machine they are the same subject: what the robot can hold, and how the boards that hold it are organized.

The exact address map — where in the 8088’s space each region of RAM and ROM lands, how the optional cards are decoded, and how the slave processors’ local memories are addressed — is not reconstructed here. That belongs to the factory ET-19 Technical Manual, which is the authoritative primary a restorer or programmer should consult for the definitive layout. This volume reports the capacities and the card organization the public record establishes, and leaves the addressing to the manual.

Read/write memory — 24 KB base, 576 KB ceiling

The HERO 2000 starts with 24 KB of RAM and is expandable to 576 KB through optional memory cards (theoldrobots.com; robotworkshop.com). That base figure is the same 24 KB that the fully-expanded HERO Jr reached as its maximum; on the HERO 2000 it is merely the floor. The expansion is described in one source as proceeding via “three optional memory boards” (the record gives this phrasing without itemizing the per-board capacity), and the documented card set names a Memory card as one of the cage’s boards (selectric.org). Beyond that — the exact capacity of each optional board, how many cards are needed to reach the ceiling, and which slots they occupy — the public record does not specify, and this volume does not invent it. What is firm is the span: 24 KB at the floor, 576 KB at the ceiling.

That ceiling deserves perspective. The 8088 master is a member of the same processor family as the IBM PC/XT and the Heath/Zenith Z-151, an architecture whose real-mode address space tops out near a megabyte (selectric.org; Vol. 2). A robot carrying up to 576 KB of user-accessible RAM in 1986 was carrying a respectable fraction of a contemporary personal computer’s memory, on wheels, available to hold robot control programs, sensor maps, and data. The memory is what makes the HERO 2000 a development platform rather than a fixed-function appliance: programs large enough to be written in a full BASIC, with room for the 360-degree sensor data the ring produces (Vol. 5), need room of this order to live in.

What the record settles, and what it does not

It is worth being precise about the boundary, because memory is exactly the kind of detail it is tempting to over-specify. The record settles three things: the 24 KB base, the 576 KB maximum, and that the path between them is optional memory cards — phrased in one source as three optional boards. It does not settle the per-card capacity, the number of cards strictly required, the bank or address ranges they occupy, or whether the 24 KB base lives on the CPU card or on a dedicated board. Those are address-map questions, and the address map is the ET-19 Technical Manual’s to give. Where a reader sees a specific HERO 2000 memory address quoted elsewhere, it should be traced to that manual rather than assumed.

Firmware — 64 KB of ROM, with a full BASIC inside

The HERO 2000 carries 64 KB of ROM (HERO 2000 spec sheet; theoldrobots.com; Computer History Museum). What is in that ROM is the more interesting fact. It holds three classes of firmware:

• The monitor — the low-level supervisory program that comes up at power-on, manages the console, and provides the foundation the user works from (spec sheet).
• HERO 2000 BASIC — and this is the headline — a full BASIC interpreter resident in ROM, not loaded from disk or tape (spec sheet; theoldrobots.com; CHM). A programmer can sit at the terminal, with no storage medium attached at all, and write robot programs in BASIC, because the language is already in the machine.
• Demonstration, diagnostic, and sensor-adjustment routines — built-in firmware to exercise the robot out of the box, to test its subsystems, and to calibrate its sensors (spec sheet). The sensor-adjustment routines in particular matter on a machine whose perception depends on a 24-bearing sonar and light ring (Vol. 5) that must be brought into alignment.

Having a full BASIC in ROM is the cleanest single illustration of the gap between the HERO 2000 and its predecessors. The HERO 1’s firmware was a roughly 2 KB monitor driving a keypad; the HERO Jr carried a 32 KB behaviour ROM — personalities and a Robot BASIC reachable largely through cartridges and one-touch keys (HERO Jr deep dive, Vols 2 and 8). The HERO 2000’s 64 KB ROM is twice the HERO Jr’s and is aimed at development: it puts a complete programming language, a diagnostic suite, and a calibration toolkit into firmware so the machine is a usable computer the instant it powers up, before any card, disk, or terminal session adds anything. Vol. 8 takes up HERO 2000 BASIC as a programming environment; here the point is simply that the language lives in this ROM.

The passive backplane — the card cage

Underneath both the RAM and the ROM is the structure that makes the HERO 2000 expandable at all: a passive backplane holding up to 12 plug-in cards (theoldrobots.com; selectric.org). “Passive” is the operative word. The backplane itself carries no processing logic — it is a wiring harness of bus traces and connectors. All the intelligence lives on the cards that plug into it: the CPU card, the memory cards, and a set of controller cards, each of which (per Vol. 2) typically carries its own slave microprocessor to run a subsystem in real time. This is the classic card-cage architecture of period minicomputers and industrial control gear, brought into a robot’s torso.

The cards documented in the public record — itemized from selectric.org’s firsthand restoration of a HERO 2000 — are:

Table 1 — restoration of a HERO 2000 — are

Card	Role	Source
CPU	The Intel 8088 master and its support logic (Vol. 2)	selectric.org
Memory	Read/write memory; the path from 24 KB toward 576 KB	selectric.org
Motor Controller	Drives the locomotion motors (Vol. 4); carries its motor-control slave	selectric.org
Arm Controller	Drives the optional arm (Vol. 6); present only when the arm is fitted	selectric.org
Floppy Controller	Floppy-disk storage controller (Vol. 8)	selectric.org
Interface / head	The head-interface card linking the head’s sensors, LEDs, and electronics	selectric.org

This is the documented set, not necessarily the complete catalog of every card Heathkit offered — the cage holds up to twelve slots, and a fully-optioned robot with multiple memory boards and the arm fitted would populate more of them than a base machine. What the record does not give is a slot-by-slot map: which physical slot each card occupies, the backplane’s pinout, or the bus signals on it. Those are ET-19 Technical Manual details and are left unclaimed here. The table above is a roster of documented card types, not a wiring diagram of the cage.

The Floppy Controller as a memory-hierarchy note

One card on that roster belongs to the memory story as much as to I/O: the Floppy Controller (selectric.org). It gives the HERO 2000 a layer the earlier HEROs simply did not have — mass storage. The HERO 1 and HERO Jr held programs in RAM or on plug-in ROM cartridges, with no disk in the picture at all. The HERO 2000, through its floppy controller card, can read and write floppy disks, so programs and data too large or too valuable to keep only in volatile RAM have somewhere to live (Vol. 8 covers the floppy storage in detail). The memory hierarchy of the machine is therefore three deep where its predecessors’ was two: fast volatile RAM (24–576 KB), fixed ROM (64 KB with BASIC), and removable floppy mass storage behind a dedicated controller card. That a robot of this era had all three is one more measure of how much more of a computer the HERO 2000 was than the robots that bore the same name before it.

How a card-cage robot grows — the contrast that defines the design

The single clearest way to understand the HERO 2000’s memory and card cage is to set its expansion model against the two HEROs that came before, because all three solved the same problem — how does the owner make the robot do more? — in three different ways.

• HERO 1 (ET-18): accessory ROMs and add-on boards. The HERO 1 grew chiefly by the owner adding firmware and hardware to a fixed base — its capability was extended by accessory ROMs and bolt-on options rather than by a general expansion bus (HERO 1 deep dive). Memory was small and essentially fixed.
• HERO Jr (RT-1): snap-in cartridges. The HERO Jr was a consumer machine, and its expansion model matched: the owner snapped RTC program cartridges into a slot to give it new programs and behaviours, the way a game console takes game cartridges (HERO Jr deep dive, Vol. 7). Simple, sealed, no tools — and bounded by what a cartridge could carry.
• HERO 2000 (ET-19): add a card to the cage. The HERO 2000 grows the way a desktop computer grows. Want more memory? Add a memory card and climb toward the 576 KB ceiling. Want the arm? Add the Arm Controller card (Vol. 6). Want disk storage? The Floppy Controller card is already on the roster. The robot’s capability is a function of which cards occupy its twelve-slot passive backplane (theoldrobots.com; selectric.org).

That progression — accessory ROMs, then snap-in cartridges, then a general-purpose card cage — is the HERO line maturing from an appliance into a computer. The card cage is open-ended in a way a cartridge slot is not: the cage does not care what a card does, only that it plugs into the bus, so the same mechanism that adds memory adds an arm controller, a floppy controller, or the head interface. It is the most “computer-like” thing about the HERO 2000, and it is the reason this machine, alone among the HEROs, could be configured from a base trainer up to a fully-armed, disk-equipped, half-megabyte development platform without redesigning the robot.

Summary

The HERO 2000’s memory subsystem is built to grow. It starts at 24 KB of RAM and reaches 576 KB through optional memory cards — one source describing the path as “three optional memory boards” — while a 64 KB ROM holds the monitor, a full HERO 2000 BASIC interpreter, and the built-in demo, diagnostic, and sensor-adjustment routines (HERO 2000 spec sheet; theoldrobots.com; robotworkshop.com; CHM). All of it hangs on a passive backplane card cage of up to twelve slots populated by the documented cards — CPU, Memory, Motor Controller, Arm Controller, Floppy Controller, and the head Interface (selectric.org; theoldrobots.com). The robot expands by adding cards, a general-purpose model that sets it apart from the HERO 1’s accessory ROMs and the HERO Jr’s snap-in cartridges. The two headline numbers — a 576 KB memory ceiling and a full BASIC resident in ROM — are what mark the HERO 2000 as a development computer on wheels. The exact address map and the cage’s slot assignments and pinout are not reconstructed here; they are the ET-19 Technical Manual’s to provide, and a reader needing the definitive layout should consult it.