An Experimenter’s Robot Framework

When I was in my mid teens and still living in Liverpool I spent a lot of time reading technical books and magazines, electronics was my hobby but I hadn’t started my formal education in that field yet. One day I picked up a special Christmas issue of Electronics Today International (ETI) – the issue was entitled Electronics Tomorrow and it contained several fascinating articles that speculated on the future of electronics, with hints at predicting a perceived future.

One of the most interesting articles in that issue was all about the making of Star Wars and was dedicated to exploring the various robots that appear in that movie. I hadn’t yet seen the movie so I was reading of R2D2 and C3PO for the first time. In addition were some articles about the emerging microcomputer field in the USA with reports about the Commodore PET, Rockwell AIM 65, Apple 2, Tandy TRS80 and more, all cutting edge systems back then – before the IBM PC and when Microsoft were more than a few guys writing BASIC interpreters.

The robots in the magazine – and yes, I still have that original copy in my library – really captured my imagination, particularly the R2D2 unit which seemed to me to be almost within reach of the (then) current technology. I’d heard a little about microprocessors already because the regular electronics magazines that I subscribed to had started to mention these in news reports about a year or two before and some build-at-home electronics projects had begun to use them – the microprocessor age had dawned.

The year before I’d picked up my first programmable calculator a Texas Instruments TI-57 and so technically speaking I’d begun to write code. This had piqued my interest in microprocessors too so I had some basic knowledge of these early 8-bit devices like the MOS-6502 and Intel’s 8080 but I’d only read articles and a couple of books – I was excited about trying out some real ideas on a real microprocessor, the calculator wasn’t really enough – I had to get a real microprocessor and write real code.

The Acorn System 1

There were several so-called “motherboards” and “single board computers” to use the then terminology for these systems, but they were expensive too expensive for a kid still at school. Then I saw the add I’d been waiting for – the Acorn System 1, here’s some pictures of it:

The Acorn was my dream machine, it had a 6502 processor, 256 bytes of memory (yes I did say “bytes”), an INS-8154 I/O chip, built in firmware that drove keyboard and display and allowed entry and editing of raw machine code and an interface to save/restore blocks of memory using some start address and length – it was something I could attach hardware to and actually write controller code – I ordered one!

Thus began my first robot project – with a true programmable controller, a system backup/restore (cassette tape!)  and my good grasp of electronics I dreamed of having my own real R2D2 in the near future all I had to do was write some software!

The first robot that I put together was a lot of fun, my kid sister was fascinated and my old friend Stephen (who like me was deeply interested in electronics) was eager to see what I was up to. That robot was a hand made aluminum chassis with two high quality 24V DC motors and two reduction gearboxes – all acquired from a store named City Surplus in Liverpool, now long gone.

The robot had some small microswitches such that if it hit a wall or object or approached an edge (like it might when situated on a table) an interrupt pin was signalled and code ran that sampled the switches states. That code then decided what motor controls to issue and the motors were controlled by a simple bank of relays (easier that putting together a Power MOSFET based circuit back then) the motors could be independently stopped or started in either direction (there was no speed control) so it was fairly easy to devise an algorithm to react to the swicthes in such a way the robot evaded or backed away from the encounter.

It was fun to see – the relays would click and clack like a small telephone exchange and I was amazed at what it could do, I appreciated how complicated yet limited a pure hardware system would have been to do the same thing. I could even program a “route” into the robot so it would wander around a predetermined path – the machine was limited but was a true programmable hobby robot nevertheless.

Programming Robots

I made a second robot some years later, this was much slicker and was another step along the road to a personal R2D2! It used a better microcomputer and had ultrasonic ranging, PWM speed control and simple light detectors. The computer used for that second robot was a Microprofessor Z80 based machine, here’s a picture:

The Z80 was a superior processor chip, more registers, more addressing modes, a set of 16-bit operations that could pair two 8-bit registers and it even had a duplicate set of registers too, very interesting to write code for but the Microprofessor was still a machine code based device, one had to hand-code on paper, review that code and then enter it byte by byte into memory before starting to execute one’s program, debugging – needless to say – was very challenging as it had been on the Acorn.

I eventually let that robot sit and gather dust and it no longer exists, once I began working as a software developer for a living I began to see that a hobby robot really should be “managed” from a desktop PC, the really sophisticated algorithms should be running on  a desktop where the potential exists to write large powerful systems possibly even AI oriented platforms.

The robot itself should contain a decent microcontroller that manages local devics like motors, cameras, speech systems, sensors and so on – but by basing the main control software on a desktop or laptop and relying on WiFi as the basis for the communications it becomes possible to envisage truly sophisticated experimenal software that allows control of the robot, admin access to it, and so on from the comfort of a desktop or laptop PC.

Furthermore if the same languages can be used for code running on the robot and and on the desktop then this will make it easier to tackle ambitious projects. Because much of the real intelligence is in the software, it makes sense to me to strive for the most powerful development and execution environment that once can.

With the advent of Gadgeteer and .Net Micro Framework it is now possible – at least in principle – to devise a robot management system that is written wholly in C# using Visual Studio, with this approach the remote desktop base station and the devices situated in the robot can all have their code created using the same tools and languages – as an experienced developer myself I see this as being a big step in creating truly impressive non-trivial hobby robots.

In some future posts and when time permits I’ll dig down into this subject further and discuss some of my ideas about how such a system could be architected and examine some of the key abstractions present in the problem domain.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s