This page describes my first robot, which was built over a period of several years from 1985 to about 1989. It actually started out as a test bed for samples from IC vendors. Electronics suppliers and distributors at that time would invite engineers from local businesses to come to hotel ballrooms where the suppliers provided workshops telling about their newest chips and technologies. They invariably gave out lots of samples and data books to those who were interested. The top part of the robot started out as a chassis that I could use to breadboard some of these chips and try them out. What you see here is a later version of the chassis by the time it had been converted and adapted to being a robot control computer.
The robot was based on a couple Intel 8085 processors in a multi-processor setup. The 8085 was used mostly because I had a version of a monitor program from an 8080/Z80 Assembly Programming book that worked well. The monitor program let me upload and test programs from RAM before committing them to EPROM. I always envisioned making an R2D2-like body, complete with arms and gadgets that extend, but never got around to it. Parts of the robot’s electronics died an untimely death one day when the external switching power supply failed in a bad way… instead of putting out 5 volts DC, it put out about 28 volts AC. Sigh. That’s a Datavue Spark laptop computer being used for software development and control of the robot in the first picture. The Spark had two floppy drives, no hard disk, and about 1 megabyte of RAM if I remember correctly. It ran at a clock speed of about 10 MHz, which was pretty fast for the time. The robot had 4 boards, with room for a 5th one that I never got around to making. The battery was a couple rather large lead-acid bricks and there was an on-board charger that could be plugged into a wall outlet when needed. The robot drive system was two motors which propelled the wheels on each side, with the front and back of the robot supported by casters. The wheel drive shafts had slotted encoders so the processor could keep track of the rotational position. There were 32 switches around the perimeter of the base that acted as sensors when it ran into something and the robot was programmed to map out its environment in that way.
Here are back views of the robot. There was a speaker on board for a voice output from an SP0256-AL2 speech synthesizer chip. That same chip is still alive and well and is now being used in my balancing robot.
Display Board and Speech and LED Display Processor Schematics
The front board is a 16×16 array of red LEDs. They are driven by a couple of 4 to 16 line decoders such that only one LED is actually on at a time. By scanning the array quickly, persistence of vision makes it appear that many are on at the same time. The second board in the rack has an 8085 processor running at 8 MHz, an 8K byte UV EPROM, 16K of RAM, a UART for RS232 communication, an SP0256-AL2 speech synthesizer, and bus buffering and decoding glue logic. The monitor program mentioned earlier was stored in the EPROM, and operating software was then loaded from the connected computer through the RS232 interface into the RAM for execution.
Motor Drive and Bumper Sensors Schematics
There were a couple interface boards that weren’t built in the main stack of cards – these are the schematics of two of them. The first one is an H-Bridge driver that powered the motors. The H-Bridge lets logic level signals specify a direction and enable signal for both motors. There was a slotted wheel attached to both drive shafts that had an optical sensor which generated pulses as the motors turned. By counting the pulses you can figure out how far the wheels have turned. The second schematic is the interface to the 32 bumper sensors. It used four 8 to 1 multiplexers to interface with the switches around the perimeter of the base. The multiplexers are scanned at a rapid rate so that a switch closure is almost immediately detected.
Motor Processor Schematics
The first schematic is basically a clone of the speech and LED processor CPU, memory, and bus decoding logic. This processor was responsible for controlling the motors, sensing the bumpers, and building up a map of the environment that the robot was exploring. The second schematic is another UART for program loading and communication and also several parallel ports that connect to the motor driver and bumper sensor interface boards. The third schematic is a large 64K byte Electrically Erasable Programmable Read-Only Memory (EEPROM) array made from eight 2864 chips. The EEPROM provided persistent memory for mapping out environment data. This is where the map was stored as the robot discovered its surroundings. If the robot was turned off, the map and other positional data would still be there and the robot could go on with its task. That’s as long as it hadn’t been moved while it was turned off! The last schematic is the RS232 to TTL level translator built around one of the original Maxim level translator chips, the MAX232.