Once upon a time, microcomputers were simple and easy to understand. So simple in fact that a kid like me, with no computer experience whatsoever, could actually understand them, build them, program them, and put them to work in his very own projects!
The COSMAC 1802 was created in the 1970's at the dawn of the microcomputer revolution, by Joseph Weisbecker of RCA Corporation. It used their new CMOS fabrication process, which had very low power consumption, very high noise immunity, and was very simple to use. It was intended for military and aerospace; applications too tough for other microcomputers to survive.
But Joe was a hacker at heart. He wrote a series of articles starting in the August 1976 issue of Popular Electronics magazine called "Build the COSMAC ELF". It described a simple low-cost computer, using the 1802 microprocessor. At the time, microcomputer systems cost hundreds to thousands of dollars. (Hmm... they still do today!) But Weisbecker's ELF cost less than $100! Yet, it was an honest-to-goodness real live computer, able to do anything its much bigger cousins could do -- albeit a bit slower and cruder.
It was the ideal computer trainer. Hobbyists built thousands of ELFs, learning about computer design, construction, and programming in the process. A dozen companies produced versions of the ELF, also selling for low prices. It was the "Legos" of computers; a simple building-block computer that could be assembled many ways to become almost anything, limited only by your imagination.
I learned about computing on my ELF. It put me on a career in engineering, as it did for thousands of others. 1802's got designed into all sorts of amazing things; video games, music synthesizers, auto engine controllers, military weapon systems, and even NASA missions such as the Galileo spacecraft. Eat stardust, PCs and Macs!
Today's computers are far more powerful than the 1802. But they have also become so complicated that virtually no one can build them or truly understand how they work. We depend on someone else to make them for us, and to provide us with the megabytes of pre-written software needed to do anything with them. You can't learn the basics if there is nothing "basic" to learn on! I decided to do something about it.
The Membership Card is a reproduction of the original Popular Electronics Elf computer, repackaged to fit in a pocket-sized Altoids(R) tin. It is entirely built with 1980's parts and technology. It uses only common low-cost through-hole parts (no custom ICs or surface-mount assembly). To use it, you don't need a modern PC, or megabytes of proprietary software. Now you can learn about computers right from the ground up, and really understand how they work!
Inside are two circuit boards, each the size of a credit card. One is the Membership Card itself. It has the 1802 microprocessor, up to 64k bytes of memory, 22 bits of I/O, clock, reset, and power supply circuits, plus a supercapacitor to maintain memory contents without power. It can be used by itself as a microcontroller for projects like the Parallax BASIC Stamps or Arduino microcontrollers. All power and input/output signals are available on the 30-pin header along the bottom.
The second board is the Front Panel. It provides the switches and lights to implement a control panel, just like the classic computers of old. The Front Panel lets you read and write to memory and I/O ports manually, without any help from software or external devices. The Front Panel also brings the power and I/O signals out to a standard PC Parallel Port connector. It's a simpler way to connect external devices, and can also be plugged into a PC for software loading or downloading, or to use the PC's keyboard and screen for 1802 programs.
The Membership Card can be purchased as a bare board with manual, or as a complete kit with all parts including the RCA 1802 microcomputer, 32k bytes of RAM, and even an empty Altoids tin to put it all in. An optional Cover Card provides a finished cover with holes and labels for all the lights, switches, and connectors.
The Membership Card continues to improve! The current version (rev.J) has two serial port connectors; one for traditional RS-232 levels, and one for TTL levels. If your PC doesn't have a serial port, an FTDI USB-serial adapter (for example, www.sparkfun.com #9718) plugs right in. The red/green Q/EF3 LED indicates serial data transfers. A second memory chip socket allows expansion to 64k of memory. How did we add one more memory chip to this already-full board? Easy! The photo shows the 0.3" wide 32k RAM chip that hides underneath the 0.6" wide EPROM.
The Membership Card is your ticket to the fascinating world of microcomputing. Return with me now to those thrilling days of yesteryear, when the heroic pioneers of the microcomputer revolution built their own computers from scratch, and learned to program them to do incredible things, all for a tiny amount of money!
Want to build your own Membership Card from scratch? Or make your own expansion boards that plug right in? The Membership Card Protoboard is just the thing. It's precisely the same size, to fit inside an Altoids case.
It has a grid of 0.060" pads with 0.040" holes on 0.1" centers to breadboard your circuit, as well as labelled connector locations and mounting holes to match the 1802 Membership Card. This is no cheap phenolic crackerboard; it's a high quality glass-epoxy board with precision plated-through holes.
It all started because my son loves Minecraft. And, he is very hard to get out of bed in the morning. So how about an alarm clock that is truly "alarming"? It's a one-off project I just built for him, but now there's a PC board available, so you can build one yourself (or contribute, kibitz, or heckle as you see fit).
Minecraft has a character called the "Creeper". He's like a suicide bomber -- he sneaks up on you, and then EXPLODES! So I decided to build a "Creeper" alarm clock. I bought a cheap Creeper mask on a post-Halloween sale on eBay. It's actually nothing but a cardboard box printed to look like the Creeper's head, and intended to be worn like a helmet. I put the clock display behind the eye holes. The rest of the box is just a big speaker enclosure, with a real LOUDspeaker in it -- not the wimpy little things found in commercial alarm clocks, but a big 10" monster. As it gets close to the set time, it starts ticking like approaching footsteps. Louder and louder, closer and closer, until a big KABOOM! explosion sound at the end. The only way to prevent the explosion is to shut it off before the footsteps stop!
An 1802 Membership Card ran the whole thing. Only the 1802 card was used; the Front Panel card was not needed. An AC "wall wart" provided both power and a 60 Hz reference to keep accurate time.
A clock display made with 7-segment LEDs (18:88) needs 2+7+7+7 = 23 LEDs. I also wanted LEDs for AM, PM, Time, Alarm, and a colon between the hours and minutes; that's 5 more, for a total of 28 LEDs. The Membership Card's output port has 8 bits. To drive 28 LEDs with 8 bits, I needed to multiplex them, i.e. divide the 28 LEDs into 7 rows and 4 columns.
I didn't have 11 output bits (7 rows + 4 columns), so I used a 74LS145 1-of-10 decoder to drive the rows. 3 output bits select 1 of 8 rows (the LED cathodes). The remaining 5 output bits drive the columns (LED anodes). This provided an 8 x 5 matrix, which can actually drive up to 40 LEDs; lots of room to grow! The 1802's Q output drives a simple audio amplifier to "bit bang" the audio for the speaker.
I had a bag of orange LEDs from a previous project. I used two in series to make each segment, for a unique appearance (and made it easy to use just about any shape or color you like). The LEDs also provided a 4v drop, so I can get by without series resistors. Here's a photo of my LED display:
The multiplexing was a little different from the usual method of scanning digit-by-digit (light all segments needed in the 1st digit, then all segments needed in the 2nd digit, etc.) Here, I needed to scan by segment (enable the "a" segments of all digits, then enable the "b" segments of all digits, etc.) This was a consequence of not having enough output pins, and not wanting to add more chips to get around it. It also made the software more, ah... "entertaining".
Another fun little quirk: I used an early version of the 1802 Membership Card that only had one memory chip (U2). It could be RAM or ROM; but you couldn't have both RAM and ROM. Since I didn't want to reload the program every time the power went off, the program was burned into a 27C16 EPROM. The 1802 was quite happy to run with no RAM at all, just using its internal registers. :-)
Aug 2017: After years of inquiries, I finally got around to making a PC board for this project. Got a Membership Card that's not doing anything? Put it to work! Plug this board onto it (any version) to make your very own Creeper clock. Since the Membership card is just a repackaged Elf, it should also work with any other 1802 Elf computer.
Interest in vintage computers has led to a growth in Vintage Computer Shows, where people can see and show these amazing machines in operation. Members of the cosmacelf.com forum decided to have an 1802 booth at the Vintage Computer Festival Midwest in Chicago. It was a great opportunity to demonstrate the wide range of applications for the 1802; past, present, and future. We had so much fun that we've done it three times (2014, 2015, and 2016). Now we're looking forward to 2017!
We had examples of the earliest RCA development systems, ELF computers built from the Popular Electronics articles, commercial 1802 systems, and more! It was so much fun that we plan to do it again. Details on this year's VCF-MW are here. If you're in the area, stop by and say hello!
I helped man the booth, and brought along examples of the Membership Card, Nametag, Face Card, and other 1802 systems. It was a great chance to meet many owners face-to-face, exchange ideas, and come up with even more projects for this amazing little CPU.
The photo at right shows our booth. That's Josh Bensadon, Lee Hart, Bill Rowe, and Dave Ruske (from left to right). A BIG thank-you to Dave, Bill, and especially Josh for working so hard to pull this all together.
PS: Notice the T-shirts? We had them specially made for the show. :-)
Hundreds of Membership Cards have been sold. Now that you have yours, what did YOU do with the 1802? Send me links to your projects, and I'll add them here!
NASA's Galileo mission to Jupiter used six 1802's, so I decided to build a model of it for the VCF-MW show (above). It contains a working 1802 Membership Card, which is sending the Arecibo message in Morse code via a blinking LED (seen at the very top of the model).
The model was built from scratch, based on photos found on the web and a paper model from spacecraftkits.com. It was constructed from pieces of scrap PCB material, copper wire, electronic parts, and bits of brass from a model railroad hobby shop. Befitting the project of an EE, it's all soldered together.
The Membership Card inside is powered by three AAA cells. The program is in a 27C16 EPROM. Power consumption was 0.24ma for the computer, plus 20ma when the LED was on. The batteries lasted for the entire 2 days of the show (and they were used to begin with). Low power consumption was one of the big reasons why the 1802 was used in spacecraft.
Herb Johnson was so impressed that he built a web page to illustrate the construction of this model. (Thank you very much indeed, Herb!) It has lots more photos, links to the program that sends the data, and much more information.
Herb Johnson has been working with the Membership Card right from the very beginning. Rather than use a parallel port, he installed an EPROM at U2, a 32k RAM at U8, and connected the Membership Card's serial I/O to the serial port of his PC.
The EPROM contains the IDIOT monitor program, which is an improved version of RCA's classic UT4 monitor from 1976. It "bit bangs" a software UART using the 1802's Q and EF3 pins. The program can examine and change memory and registers; load and save programs in hex format, and run programs with or without breakpoints.
The monitor has a number of features to make debugging easier. It is page-relocatable, so the EPROM can be addressed on any page boundary and will run without changes. It searches for RAM, and adapts to whatever it finds. Since serial data formats can be confusing, it uses the first character received to determine the baud rate. There are four versions of the program in the EPROM, each configured for a particular serial input/output data polarity (normal/normal, normal/inverted, inverted/normal, and both inverted). A version can thus be chosen to work with just about any CPU clock speed, memory map, serial baud polarity, or baud rate.
Herb has put together a kit with all the parts needed for this serial interface, and instructions on how to install and use it. The kit comes with a pre-programmed EPROM, a 32k 0.3" wide RAM, a 25-pin male D-connector that plugs into the Membership Card's Front Panel, a 9-pin D-connector that plugs into a standard PC RS-232 port, and instructions. Details are provided on his Web page to build it yourself, or order a kit directly from Herb.
The photo shows the kit installed on his rev.G board set. Note that he used BLUE LED's. He suggests changing SIP resistor R11 from 1k to 4.7k, so the LEDs draw less draw less than one milliamp each. If you don't change the SIP, you'll get blinded!
Bill Rowe has been very busy with his Membership Card. He noticed that there were lots of accessory boards (called "shields") for the Arduino microcontrollers. So, he made the Olduino adapter board to plug in and control Arduino shields with a Membership Card!
Since Arduinos are programmed in C, Bill developed an 1802 C compiler to program the Membership Card. He's controlled LCD displays, ethernet adapters, interfaced SD memory cards, and more. Quite an impressive feat! Take a look at Bill's site -- he's put a lot of work into this, and achieved some impressive results. The photo at right shows the Membership Card on the left and Bill's Olduino on the right.
Chuck Bigham didn't have a parallel port on his PC. So he programmed a PICAXE microcontroller as a RS-232 serial-to-parallel converter. He also wrote a Windows program to provide a control panel. The project is documented with schematics and software at RS-232 serial to parallel adapter. Thanks, Chuck! I've always wanted to play with the PICAXE micros, and this gives me an excuse.
Mark Moulding also built a serial loader, but he used an 8051-class microcomputer (the Atmel AT89C2051). It accepts data from an RS-232 port (or USB port with USB-to-serial adapter), and loads it into the Membership Card parallel port. It can accept hex files directly from DOS, coming from an assembler or simple text program. Herb Johnson has collected Mark's work here.
Mark Thomas took a different approach. He "piggybacked" a 32k EPROM on top of the 32k RAM chip on his Membership Card. This gave him a computer with the full 64k of memory. The EPROM was programmed with Spare Time Gizmo's Elf2K 1802 software, which contains not only a serial port driver, but also a monitor, editor, assembler, BASIC, FORTH, and a whole bunch of other stuff.
This approach requires some fiddly hand wiring. The EPROM can be a one-time-programmable type because it is no longer socketed. Information on Mark's approach is here. Note: You'll have to be a member of the Cosmac Elf Yahoo group to view it.
I liked Mark's approach so much that I incorporated it into the Rev.G version of the Membership Card! I used a 0.3" wide 32k RAM, and laid out the board so it hides underneath a standard 0.6" wide EPROM. There are jumper options to put either RAM or EPROM at 032k or 32-64k.
The Rev.D and later Membership Cards are set up so you can stack two boards. This gives you two memory sockets; one for RAM and one for ROM. This is an easy way to add the Elf2K or other ROM. It also adds a second 8-bit input and output port.Basically, the top board has a wirewrap socket for the 1802. The 1802 plugs into it. The long wirewrap pins extend down, and plug into a socket on the lower Membership Card. Cut off pins 1 and 38 of the wirewrap socket, so the Clock and DMA-IN circuits on the bottom board won't fight with those on the top board. Transistor Q1 can be installed in either of two positions, to address its memory chip at 0-7FFF or 8000-FFFF. There are jumper options to select the I/O address for each board separately.
See the manual for more details. The Membership Card bare board can be purchased by itself for $9.95 if you'd like to take this route. The irrepressible Herb Johnson has pulled together the notes on this here. If there is enough interest, I can make up a kit with just the parts needed.
Chuck Yakym's approach was to build a board with a clock, a 4040 counter, and an EPROM. This board can plug into the 25-pin connector on the Front Panel card, or directly onto the Membership Card's 30-pin header (so no Front Panel Card is needed). When you press the "Autoload" button, the clock steps the counter to sequentially address each byte in the EPROM. The outputs from the EPROM go to the INPUT switches. The IN button is pressed for each byte, so it automatically loads the EPROM's contents into RAM, just as if you had set the switches and pressed IN to do it manually.
This little project is an 1802 Name Tag. It shows just how much you can do with an 1802 and an absolute minimum of resources! It's the size of a credit card, and runs on just 10ma from three AAA cells (4.5v). That's low enough to run for days.The 1802 scans a multiplexed 8-digit 7-segment LED display to produce four 8-character message "frames", displaying them sequentially about one every second. Every segment in each message is programmable, so it can spell out text as well as numbers.
It uses an 1802, a 74HC241 octal buffer, and a 74HC138 1-of-8 decoder. Astute observers will note that there is no RAM or ROM! Yet, it is running a program and scanning the display. It even has a 'front panel' for loading messages, which since it is an 1802, needs nothing but switches and LEDs.
How can it work? Where is the program? Where is the data? Unique features of the 1802 make this possible. The schematic reveals the secret. The data is stored in the 1802's registers. There are sixteen 16-bit registers (32 bytes). That's enough to hold the four message frames of 8 bytes each.
The program is produced by the unusual configuration of resistors between the data bus and power, ground, and the address bus. Each fetch cycle gets an opcode to read a register. Each execute cycle displays that register's contents in its associated LED digit. As the program counter increments, each address is one higher, which produces an opcode one larger, to read the next higher register. The program is thus 80h, 81h, 82h... (GLO R0, GLO R1, GLO R2...). This reads and displays the lower byte of each of the 16 registers. At 8Fh (GLO RF) it advances to 90h, 91h, 92h... (which are GHI R0, GHI R1, GHI R2...). This displays the upper byte of each of the 16 registers. Tricky!But wait; there's more. :-) Address bits A0, A1, and A2 scan the LED digits (with help from the 74HC138 decoder). Address bits A10 and A11 are wired so each 8-instruction sequence repeats 128 times before advancing to the next one. This makes each 8-character frame get displayed for a second before advancing to the next frame.
The 74HC241 octal buffer is actually being used as two 4-bit latches. I couldn't use a standard octal latch, because the high address bits need to be latched at TPA, and the low bits at TPB (and saved for the subsequent execute cycle).
This all works; but the LEDs would be quite dim because they are only active half the time (off during each fetch, and on during each execute cycle). So a simple wait-state generator is added, to make the execute cycles far longer than the fetches. The LEDs are thus active 99% of the time, for good brightness.
A "Programming Panel" (above) is used to load your messages into the registers. Each register bit maps to one segment in the display, as shown in the segment map at right. Just like an Elf or the Front Panels on computers of old, you toggle in a program in hexadecimal to load the registers like this: F8 data0 A0, F8 data1 A1, F8 data2 A2... (LDI data0, PLO R0, LDI data1, PLO R1, LDI data2, PLO R2...). Surprisingly, it doesn't use the 1802's LOAD mode. Instead, it uses WAIT to hold the CPU for the next byte. It would probably work with an 1804/5/6 (versions of the 1802 that are otherwise impossible to use without an external ROM).
This is a great "quickie" project! If you like puzzles, or enjoy trying to figure out how such a "mad" circuit works, click on the schematic link. The manual and segment map for programming it are also available at the links below. You can also order a parts kit with the "Buy Now" button. You'll have to build your own programming panel; for this you'll need nine SPDT center-off toggle switches, nine 3.3k resistors, and an LED.
The 1802 Membership Card Microcomputer, © 2006-2018 by Lee A. Hart. Created 8/5/2012. Last update 8/7/2018.
Go to TOP ........ Go to HOME ........ Questions? Comments? Email me for details.
Web hosting provided by Innovative Computers.