Before Arduino There was Basic Stamp: A Classic Teardown

Microcontrollers existed before the Arduino, and a device that anyone could program and blink an LED existed before the first Maker Faire. This might come as a surprise to some, but for others PICs and 68HC11s will remain as the first popular microcontrollers, found in everything from toys to microwave ovens.

Arduino can’t even claim its prominence as the first user-friendly microcontroller development board. This title goes to the humble Basic Stamp, a four-component board that was introduced in the early 1990s. I recently managed to get my hands on an original Basic Stamp kit. This is the teardown and introduction to the first user friendly microcontroller development boards. Consider it a walk down memory lane, showing us how far the hobbyist electronics market has come in the past twenty year, and also an insight in how far we have left to go.

The Basic Stamp 1. A Simple circuit with just a microcontroller, an EEPROM, crystal, and brownout circuit.
The Basic Stamp 1. A Simple circuit with just a microcontroller, an EEPROM, crystal, and brownout circuit.

Teardown

The Basic Stamp kit on my workbench was made in 1993, and sold for a suggested retail price of $139 USD. Adjusted for inflation, this is nearly $230 in 2015 dollars. What do you get in the Basic Stamp starter kit? A single stamp, a programmer cable, and a surprising amount of documentation.

The Basic Stamp is an extremely minimalist board that does just enough to blink an LED, read a button, or drive an LCD. In the official documentation,  there are only a handful of parts: a microcontroller, an EEPROM with a few bytes of memory, a crystal, and a voltage regulator.

The PIC16C56XL is the brains of the outfit, featuring 1.5kilobits of Flash memory and 25 bytes of RAM. By modern standards, it’s tiny; the closest modern analog would be the ATtiny10, itself not a very recent chip. Microchip’s smallest and newest chip is the PIC12LF1522, featuring twice as much Flash and ten times the amount of RAM. We’re dealing with an old microcontroller when using the Basic Stamp

Like the Arduino, it was encouraged to use the Basic Stamp in product design.
Like the Arduino, it was encouraged to use the Basic Stamp in product design.

Other components include a 93LC56 serial EEPROM. beside that is a 4MHz resonator, a 5V linear regulator, and a transistor and a few resistors for the ‘brown out’ circuit. Power is provided by a 9V battery connector soldered onto the board.

The electronic design of the Basic Stamp is simple, yes, but there’s a method to the madness. The code you write for the Basic Stamp is stored in 256 bytes of the EEPROM. This code is read by a PBASIC interpreter on the PIC, dutifully following commands to blink a LED or display a character on an LCD. No user code is actually stored on the microcontroller.

BasicStamp

Programming

How about the programming environment? That’s a single executable running in a DOS shell. The system requirements are only, an IBM PC or compatible, DOS 2.0+, 128k of RAM, and a disk drive. Meager requirements, but this is not something that will run on your modern Windows workstation; it requires a proper parallel port.

For an IDE, the Basic Stamp editor is comparable to earlier Arduino IDEs; Alt+R runs the program on the Stamp connected to the computer, Alt+L loads a program, Alt+S saves a program, and Alt+Q quits the editor.

The BASIC language implemented on the PIC is minimal, but it does everything you would expect; individual pins can be set as input and output, buttons are debounced, and PWM functions are baked into the language.

Basic Stamp Ad
An ad for the Basic Stamp. From High Tech Entrepreneur, October/November 1993. Ads had text in the past.

Context

The Basic Stamp is now regarded as a slow, inconvenient artifact from the past. No one uses it, and the only place you’ll find one is in the back cabinet in a physics or EE classroom. This is an incredible disservice to a still-impressive piece of technology, and looking back at the Basic Stamp with our modern expectations is an incredible bias.

There were microcontroller development platforms before the Basic Stamp, but these were engineering tools, and expensive compared to the Stamp. Development platforms for the electrical hobbyist were around after the stamp, too: the Micromint Domino packed an entire development platform into a rectangular brick of plastic. None of these designs could match the popularity of the Basic Stamp despite the platform’s shortcomings.

The Arduino receives a lot of hate. Detractors say it’s too high-level for proper embedded programming, not high-level enough for a modern workflow, is based on old, obsolete chips, doesn’t have the features of modern ARM microcontrollers, and the IDE is a mess. Despite an even less capable IDE, meager memory, and a slow processor, the Basic Stamp proved incredibly popular. The fact that you could pick up a Basic Stamp development kit at any Radio Shack probably didn’t hurt it’s popularity, either.

Now, with our fancy IDEs, mbed microcontrollers, powerful ARMs, and huge libraries, the ease of use of the Basic Stamp has still not been equaled. It may be slow, outdated, but all of us owe a great debt to the Basic Stamp for introducing an entire generation to the world of embedded programming, microcontrollers, and electronics tinkering.

120 thoughts on “Before Arduino There was Basic Stamp: A Classic Teardown

      1. I bought my first BS1 kit in early 1994 (still have the BS1 module and it works to this day) for $100. I’d seen the ads and thought it was too good to be true. I opened the package one night after work and had so much fun I didn’t get to bed until about 10AM the next day.

        FWIW, I am biased. I took over Scott Edwards’ “Stamp Application” column in Nuts & Volts and worked for Parallax for six years. Now I work with another former Parallax employee building controllers targeted toward entrainment and we still use the BS1! (even places like Disneyland use it).

        This is our BS1, packaged for light industrial use:
        http://www.efx-tek.com/topics/prop-1.html

        This little controller lives in lots of nooks and crannies of the Magic Kingdom doing simple control tasks. It’s easy to program, durable, and low cost (even they worry about costs).

        For those that have never tried the Propeller, it comes from the same genetic bloodline as the BS1, because both are of the mind of Chip Gracey (founder of Parallax). The goal is the same: build a micro that is easy to program yet puts power in the hands of the user.

        No processor is perfect for every application. Chip’s goal was to help people get started in embedded programming and control. I don’t think anyone can argue that he succeeded.

        1. Apparently there are some scripting capabilities that fall out “naturally” from Stamp PBASIC that have yet to get easy-to-use equivalents for things like Arduino. (Using “DATA” and “READ” statements.) Here’s some discussion: http://forum.arduino.cc/index.php?topic=36789.0 (Hmm. Was that you?)
          And the thing is, the fact that an Arduino is cheaper and faster than a Stamp is essentially irrelevant in markets like prop-building, as long as the stamp is fast enough and cheap enough. And while the Arduino community might hand-hold a lot of artists and beginners, companies like Jon’s are hand-holding prop builders, which can easily end up making a stamp a better choice.

          1. Are you kidding me? Why do you need the DATA and READ statements when you can just handle data arrays and memory pointers properly?? C is the most widely used language for low level programming and there is a good reason for that.

          2. Philosophically, you could probably say that “files” are a useful fundamental data structure, and BASIC includes a trivial but useful implementation as part of the language, and C doesn’t.

          3. How doesn’t declaring a char mydatavar[] = { 0x45, 0x43, 0x50, 0x12, 0x23, 0x00 } in C does not make a proper equivalent to DATA in BASIC? Clearly it sounds like you never really moved on from BASIC, I doubt you have any experience with C.

        2. And this is why legacy systems/languages survive forever: “ZNEW looks ok, but could we have a feature like X…” “Y is just like X!” “No, I don’t think that…” “If you don’t see why Y is just like X, you are a hopeless ignorant savage, probably incapable of using ZNEW anyway!”
          You could try actually reading the thread I referenced…

        3. I ran across those boards when I was walking around behind the scenes at the Magic Kingdom on a private tour with some staff engineers.

          Years later someone ( NDA) contracted me to design a small controller and used one of those boards as an example. They wanted one using a Micromite, and one with an Arduino compatible chip. They went with the Micromite design in the end. After a couple of prototypes and minor changes they ordered 2000 of them at once. As far as I know they still have boxes full of them stuffed away in closets.

  1. Still have one of these, though I haven’t pulled it out in years. I believe it is still set up for the same purpose I bought it for back in about ’93 or ’94: Tach and ignition advance on a CB400F, when the original (mechanical) advance froze, and I built an electronic ignition for it. This little guy was fast enough to count revs, output RPM to a display, and produce an advance output to the electronic ignition, based on RPM and change (accel, decel, or steady). Not quite enough to deal with a throttle input, nut, then again, this bike didn’t have an accelerator pump, CV, or anything. Just 4 bare two jet, mechanical piston throttle, gravity fed Mikunis. As I recall, a full control cycle was about 100ms, which was sufficient. I don’t remember the display update rate. It was maybe 2/sec.

    1. Try modern 51 on steroids – Silabs 51F series, a lot of hardware features which one is imho best = crossbar – configurable pinout, do u need half of analog pins on other side? no problem. Switching during operation is also possible, so have RX/TX on one pin is nice trick.

    1. BS2 was my first exposure to microcontrollers in high school. I was immediately hooked, then making anything I could think of with a servo motor, LDR and a few switches. Eventually I got turned onto java programming via the javelin stamp, a great little stamp board that fit in my boe bot board, albeit terribly slow. I don’t think I would have a job as a computer engineer and embedded systems designer if it wasn’t for the stamp kits.

  2. My first encounter with embedded programming was a Basic Stamp II Board of Education kit from 2009. Granted, this was well into the Age of Arduino, but considering that my school wanted a full kit that came with some sort of robot chassis, the BSII was actually the best price available. I took robotics in high school, and absolutely fell in love with the damn thing. Later on I bought the same kit (I still have it!) and eventually would use it in a lot of first year engineering school projects until I finally caved and bought an arduino with all my friends. Years later, I’m still using the BoEBot chassis Parallax sold with it, but now it’s loaded with ARM cores, and I’m going to be graduating with a focus in embedded engineering. I actually owe the BSII so, so much.

  3. Scott Edwards wrote an article, published in (IIRC) Computer Shopper magazine. In it, he described how to build a “counterfeit” Basic Stamp. He sold kits for the thing, but I sent off a money order to Parallax and built my own on a Radio Shack protoboard. That was my first experience with microcontrollers (although I did have decades of experience working on computers.)

    Since then, I have actually met and talked with Parallax’s Chip, the designer of the Basic Stamp, a few times – he actually took time out to spend a few hours talking with my teen-aged son to encourage him to get into engineering (and my son is now going to school for his Computer Engineering degree, thanks Chip – you ‘da man!)

    1. cost of tickets has definitely kept me away. I’ve been wanting to go for years but the very high cost is a show-stopper for many of us. too bad that ‘live events’ cost so much, these days (sports, concerts, you name it; its too expensive and its money that does not buy anything tangible).

      1. Besides finding a computer with a proper working parallel port?

        Not sure about the STAMP but IIRC I had a different PIC based board I used to use just used the parallel port to bit bang the data on one line. That could be done using a modern USB based microcontroller. As for the protocol… well….

        1. And.. you KNOW they all still work.. That was back before manufacturers built criminal fraud into every device and made them self destruct as soon as the warranty was expired.. I’ve had one sitting out in an open fronted car port for almost 20 years sitting on a shelf.. exposed to heat, and moisture, freezing cold, all sorts of spiders and bugs crawling in and out of it.. and ya know what… I blew it out with the air compressor, plugged it in on my workbench, and it still booted up and worked just fine.. I can’t get a motherboard made now to last more than a few years past warranty expiration without it self destructing itself.

      2. Parallax has maintained the editor software and still offers it for download on their website (see link below). The most recent version I’ve used ran on Windows 98, so I can’t comment on the newest version. The old one was simple and easy to use though.

        https://www.parallax.com/downloads/basic-stamp-editor-software-windows

        The basic stamp requires a serial port to program. Many of the development kits had a serial port, but if you’re programming a “bare” stamp then you may have to wire up an adapter to the correct pins.

        1. Besides the Windows-only BASIC Stamp Editor, Parallax is working on a new editor called Parallax IDE developed using the Chrome App Engine; currently supports Windows, Mac, Linux, and Chromebook. It compiles BASIC Stamp code locally, just like the original BASIC Stamp Editors do.

          At this time it’s still in its infancy and only a couple hundred people know about it, but you can look at the current release here: https://chrome.google.com/webstore/detail/parallax-ide/djbdelcnligmaaddjeenddjodmiaoffo

      3. Try running up DOSemu on Linux. I don’t think I’ve tried it with the STAMP stuff, but the parallel port handling is good enough to drive things like EPROM programmers.

        Apropos the STAMP itself, it wasn’t quite the first since I think that Zilog put a BASIC interpreter on one of their microcontrollers some years earlier.

          1. It was a very early Zilog micro-controller that had the inbuilt basic interpreter and NOT the Z80 **CPU**. From memory it was a Zilog Z6871 micro-controller with a very small 2K BASIC built into ROM. It had the odd ability to mix BASIC with assembly and still has a following now even though obsolete. It was based on the Z8 core that is NOT directly compatible with the Z80 (like eZ80 or eZ180) as far as I know. Fans of this chip now use a very similar micro-controller (without ROM) and add the BASIC in external ROM and in this way make a board that is a plug in replacement for the original.

      4. One of those handsome fellows? Yes if the current Windows based IDE supports it. They sell and adapter who plugs onto the pins. Use that and a serial to USB adapter to do the job. They also sell an FTDI based adapter who’s worth large heaps of diamonds.

  4. One of my first embedded boards was an 8052AH basic board from Elektuur (now Elektor) one could program it trough the serial port. The board was able to store the program in the onboard EPROM when the required programming power was applied. There was a simle I/O port on one connector and the full CPU bus was available on another.
    Simple and very slow, but I learned the basics of writing software for embedded systems… now a part of my daily job (all C now).
    That’s one of the reasons why I like Arduino for any starter, low level, easy to understand and the option to dig deeper and write your own code on the Atmel.

    This board was sold in 1987.

  5. I used Basic Stamp 1 and 2 often and then started programming PICs with the PICBASIC compiler when that was released. PICBASIC compiler converted a BASIC Stamp file into a compiled .hex file so the project could run 15 times faster in a PIC and use the many PIC features such as built-in ADC and timers. It was a great learning platform as well. I helped a lot of people learn embedded programming with Basic Stamp/PICBASIC through my books and articles using this development path long before Arduino ever existed. Nice to see it mentioned on Hackaday.

    1. Long live the PicBasic Compiler: 90% of the code in basic and 10% in assembler for time critical functions and interrupt handlers. Still using it for the small 12Fs. Always liked how even programming in basic you understand and learn the core functions of the chip setting all registers, optimizing code space, and flawlessly changing back a forth from ASMBasic.

      1. PicBasic Pro user here. It’s still very much alive. I think they call it PB3 “Gold” now as far as revisions? I like it because it works with so many different part numbers so I can easily scale the part to my project.

        I use everything from tiny little 12F parts to the latest 18F parts and never run into any brick walls. I don’t need a full development board just to blink a light or even run a full graphic LCD. Money well spent as it’s paid for itself over and over again. The IDE is wonderful compared to that arduino crap, if you can even call arduino a proper IDE…

        C is powerful, no doubt, and yes I had to learn it in college and use it regularly. But basic is actually readable without making my head hurt and does everything I need. And if anyone else ever needs to understand my code, they can, even with little programing experience So rather than trying to wrap my brain around something that isn’t “human”. I am done with my code and up and running in minutes and my dog can understand what the hell the code is doing. And again IT WORKS. I have nothing to prove to code elitists who self masturbate with their coding skills. Good for you. Now bug off…

        I still have a BS1 somewhere, A BS2 and the Java based one. The javelin I think they called it? But I quickly got over using full on devboards for stuff as that gets expensive. And the PICs on their own are way better than having a bloat loader or on chip interpreter. A little perf board and a soldering iron gets me by most of the time, if I require something a little more elegant, than I have a PCB fabbed specifically for whatever.

  6. I really wanted one of these as a kid but not for the price.

    Before the recent Rat Shack implosion those $139 development packs could still be found at a few of the local stores. They were covered in dust and still had that same price sticker! I even saw them hanging next to Arduinos which were being sold at their typical prices! There is one Rat Shack left open in my neighborhood. I wouldn’t be surprised to find they still have one or two. I haven’t looked in a while. Maybe they are waiting for collectable value to kick in?

    1. I have had a different experience.

      I once found BS2 BOE kits marked down to $19.99 at a radioshack!

      BS1 still on the shelves? I am not sure i believe it. Are you sure it wasnt a BS2?

    2. Price kept me away too. ’93 aged 11 I had got the hang of BASIC and wanted to start controlling real things. My parents (wisely) would not let me connect my selfmade hardware to the computer. As my hobby was self-funded the ‘stamp was a lot of lawns, papers and washed cars. Also we had an A500 not a PC.

      It was almost another 10 years before I programmed a mirco.

    1. Serial bootloaders, on chip nonvolatile code/data storage, and cheap devkits two decades before Arduino made it cool.

      Motorola / Freescale entered into the dark ages with hobbyist unfriendly Coldfire and PPCs, but the last couple of years they’ve been killing it with their move to ARM and trading out CodeWarrior for open tools and libraries.

  7. OK Here we go.
    Back and back in time. As the one guy put it “Rat shack” Up here in Canada we called it Radio shack.
    When I was around 16-17 That is about 143 years ago No hold on…. That was around 1976-1977 (God I’m Feeling Old)
    Radio Shack had a programmable kit. With leds, led dis., switches and other things. And I think about 256 BITES of ram.
    I had to move to go to the army, and I got rid of it. could never remember the name. but boy that was one of my loves and joys. I really wish I still had it.
    That was my first computer. And yes I’ve groan up from ZX81 to now with over 20 computers and 50t of storage in the house, not including Arduinos.
    Thanks for taking me back so many many years. (Feeling Old Again.)
    And if any one out there can remember the name Please pas it on to me.

    1. You are not the only “old” one as i have seen the migration from basic transistor building blocks to the first TTL chips , the 74xx series. My first processor board was a Intel 8086 SDK to learn to program (end 1981) and every thing was be done in “machine code”, later on i needed these skills to program a Fruit Grading machine.
      The worst change in programming tools was the change from machine code to assembler, the problem was that not all instructions (machine code) where available in ASM86, in the first months we appended a lot of macro’s (instructions) to the compiler. Sample: AsciAddjust uses 0x0A (10) as a constant while we are using 0x10 (16) for packing and unpacking of 4 digits into a single word.

      1. Oh god i remember trying to get my head around that. never did quite got as good as i wanted. OH K i was crap at it. I did make my fist computer from scratch got so invalid with the making I totally for got about programming it.
        it had a z80 processor n 6448 (i think) video. Spent 3 – 4 months hard wiring and soldering it together. I was in the army then so not much time. I did run the very first mobile computer department in the Canadian forces. that was cool. I had 6 fully supped up Osborn computers.

        Like I said earlier if anyone can remember the name of thows kits that would be great.

  8. I still use my BASIC Stamp kits here. I’ve largely given up on the Arduino. Instead I’m using the Netduino devices, sometimes with the help of the BASIC Stamp.

    And Brian? Where in the name of a guy named Murphy did you find it?

    Oh and Art there were two brothers who made the BASIC Stamp a success story. Chip definitely did the designing, but Ken did the marketing. Great bunch of people there.

  9. I think these guys are still in a ton of long-life (decades) industrial designs… hence, Parallax provides quite a bit of long-term support. They still sell the same (OTP) programmed PIC16C56 chip, and I believe their modern IDE will still program the old chips, without requiring a DOS terminal.

    Says something about Microchip – I’ve got to admit, I design them in a lot less frequently now than I used to (my first MCU platform), often because their processor cores, at a given price point, tend to be not as competitive as other manufacturers. But they’ll support the chip you use in your design for /decades/. The PIC16C56 is not only available from them, it’s still /in stock/ on their website, even though it’s finally in the “mature” stage at least two decades later. From what I’ve heard, they can do it partly due to the fact that they own and continue to run their own old fab lines, allowing them to genuinely support very long life designs. Impressive though. Don’t know any other manufacturer with nearly the same reputation for long term reliability / availability.

  10. “The Basic Stamp is now regarded as a slow, inconvenient artifact from the past. No one uses it, and the only place you’ll find one is in the back cabinet in a physics or EE classroom. ”

    Well, someone should tell Parallax that because for some reason they keep selling thousands every month……

      1. Mark doesn’t work for Parallax.

        I do, and I can verify: We don’t sell thousands of BASIC Stamp 1 modules per month any more, but we do sell thousands of the next model, the BASIC Stamp 2 (available since 1995).

        And, yes, we do sell thousands of Propeller chips per month.

    1. According to Parallax they’ve sold altogether some 3 million Basic Stamps. But I’d suspect that was before the Arduino came out.

      I’m sure they sell some, but they’ve branched off into other things to make money.

      Today the BS series is no longer competitive at all. It’s extremely overpriced, really slow and very limited. In short it’s a dog compared compared to Ardunio or even a PicAxe. .

      1. I have one of the oem build it yourself kit version of the basic stamp but i dont even use it as it’s old slow and a pain to work with. I would never buy a new one in this day in ages as there are countless cheaper alternatives that are faster and better.

  11. Just getting ready to order several more Parallax Sumobots kits for my high school robotics class. I like the Sumobot kits better than the BOE bots. This course will be the only formal class where our students will have any exposure to electronics and programming before they graduate high school. I have always loved the BASIC stamp and like the Sumobots. Everything works quite well with them except the IR sensors which tend to wobble around too much. This year I think I will try to cut some better adapters out on the laser cutter to keep them from moving. This is something Parallax should update (or should have updated a long time ago).

    This thread got me in the mood again for working with the Sumobots and hopefully I will inspire a few students to pursue CS or electronics. We’ll see.

  12. The Basic Stamp was the very first microcontroller I used in my FX work on movies. I think the very first movie I used them on was “Speed”, but I went on to use them on “Money Train”, “Fifth Element”, “Men in Black”, “Broken Arrow”, and “Starship Troopers”.

    I used a bunch of them on “Star Trek First Contact”; they were in the Borg suits and the space helmets. The Queen Borg costume was the first time I used a Basic Stamp 2; I needed the faster processor to do PWM to crossfade the lights (original Basic Stamp looked stutter-y when two or three outputs were PWM’ing simultaneously).

    During Star Trek I also got Microengineering Lab’s PICBASIC compiler, and I still use PICBasic to this day for quick & easy jobs. If you’ve seen those cardboard displays for the movie “Crimson Peak” that are in theater lobbies right now, the lighting on that display is running on a PIC12F1501 and I coded it in PICBasic Pro 3.

    Thanks for the writeup on the venerable old Basic Stamp, Hackaday!

  13. Yeah the BS1 may be “obsolete” but for education and some little odd jobs it’s a perfect fit. There is a modern Windows based editor which can program the old BS1 (there’s a serial adaptor which takes the place of the parallel port, which you get if you buy a modern dev kit). The modern day BS1 is a surface mount module about the size of a postage stamp which plugs into a carrier board to provide the battery clip and prototyping area seen on the original.

    For education a limited platform like the BS1 can be BETTER than a more powerful platform because it forces you to think more about how the machine is actually working, whaty ou are doing with those bits of memory, how the math is being performed, and so on. I’ve put a dozen or two BS1’s in various little industrial projects over the years when I needed a little hidden protocol conversion or to replace a dozen ugly relays with the Stamp and some OPTO-22 modules.

  14. Back in the mid-late 1990s I’d ~5 years with both BS1 & BS2 while teaching electronics at tech. institute level here in New Zealand. However this era matched a weak NZ-US exchange rate & the landed cost (+ dealer markups) was x3 that of the US. Our loved them & we spent $$$$ on BS2 class sets & cut budget corners elsewhere…

    The UK sourced PICAXE arrived ~2002, at a price near orders of magnitude less than BS2, with shipping far lower too. (Bulk orders meant the entry level PICAXE-08M could be landed here for ~US$3 ). I soon penned a series of supporting PICAXE articles for the likes of the Australian “Silicon Chip” monthly

    We abandoned the costly Basic Stamp approach for teaching as PICAXEs “cut the mustard” so much better. Best of all the low PICAXE costs meant students could take their project away for later ‘show off’ use at job interviews etc.

    Although some time back (and I’ve moved on to other things), but I often still “reach for a PICAXE” when evaluating ideas!

  15. “Microchip’s smallest and newest chip is the PIC12LF1522”

    Not so it is the PIC10F200 with 256 ILOC in flash and 16 bytes of RAM.
    For Atmel it is the ATtiny4 with 256 ILOC in flash and 32 bytes of RAM.

  16. Parallax still exists, and still sells various Basic Stamp boards, including versions of the original “Basic Stamp 1″…
    It’s hard to comprehend, these days, how revolutionary this was when it came out (and for quite a while thereafter.)
    A 25MHz i486 was a good computer; Windows was at version 2 and most people still used DOS. The previous “easy to use” single-board computer was based on an 8052 with a BASIC interpreter, which ran about $30 for the microcontroller chip, plus it needed external RAM and several other support chips, and an EPROM programmer if you wanted to permanently store a program. A typical system would be a 4×6 PCB with about 8 chips, costing $100+. Along came the Stamp, at $40 for a complete module (I don’t think the $140 starter kit lasted very long; I remember the PC software being free, and many people making their own programming cable.) It had other innovations as well:
    1) The first module that did preprocessing (to byte codes) on a PC (thus requiring a PC. The 8052BASIC systems could be programmed with an ascii terminal.)
    2) Serial Input or output on every pin, leading to an explosion of TTL Serial “peripheral modules.”
    3) Parallax did a really good job of balancing the slow speed of serial-loaded interpreted bytecodes (~1000 i/s) with powerful and useful bytecodes. Most of the stuff that couldn’t be done in user code (say, reading or writing a pulse with 10us resolution) ended up with a PBASIC keyword that would do the work.
    4) Use of serial EEPROM for program storage. (This was well before other rewriteable memory technologies, or even flash/eeprom based microcontrollers existed.) (and this made the Stamp one of the few non-volatile microcontrollers usable without purchasing an expensive programmer.)
    5) Parallax put a lot of effort into educational aspects; you can find whole curricula with “kits” that you can purchase from them.
    6) Nice follow-on products. Faster, bigger, more capable. Improvements to the programming language. Bare chips for OEMs to build into products (~$10) Excellent legacy support (like I said, you can still get BS1 equivalents!) Serial port programming adapters to counter the death of parallel ports.
    7) Parallax seems to have done a good job of protecting their Intellectual Property, and has behaved pretty well (AFAICT) as an owner of “proprietary intellectual property.”

    On the other hand, it had some weaknesses as well, and it’s not too surprising that Arduino started overtaking them (15 years later!)
    1) Parallax chased performance enhancements over cost reduction. While I can respect that as a business decision, I always wanted a BS1 equivalent burnt into a modern PIC, with internal oscillator, (parallel) internal EEPROM, and plenty of flash/ram. You could have a $3 single-chip solution with a nice edge over the original BS1. (There was a “Quarter Stamp” 3rd-party project that did something like that on a PIC16F84, but it died, or was suppressed, and there was no followup for the newer PICs.
    2) Speed. 1000 i/s on the BS1 (or less.) maybe 20x faster for the fastest BS model. Compare that to the “horribly slow and bloated” Arduino digitalWrite() function that executes at about 200k/s. You were really dependent on having the PBASIC keywords do a lot of your work for you.
    3) BASIC. Well, BASIC-like. And not a very modern BASIC, either. Combined with the extensive use of special keywords and limitations of the chips (14 byte of variables on the BS1!) you wound up with programs that looked like an especially high-level assembler, rather than any modern programming language.

    Definitely an important part of computing history, though.

  17. In the article you mean ” a 4MHz ceramic resonator” instead of ‘regulator’, correct?

    I never understood why Arduino choose C instead of BASIC which is much easier to be taught. It makes me wonder that the Arduino was not meant from the beginning for the so called ‘makers’, but it was adopted by them. Would a BASIC Arduino spread faster than the original?

      1. So “arduino” can build boards using someone elses chip and then program it using a language mooched off of someone else for free. Then all the have to do is make some boards to support the chip., which is pretty much a one shot job. Throw together some haphazard “IDE” and then watch the money roll in…

    1. Been wondering that myself. Keep in mind, you really can’t answer this question if you came into the Arduino with programming experience – most languages are already C-like these days. If you were say a high school (or earlier) student, wouldn’t BASIC be an easier way to start people off gently to embedded electronics? It removes the necessity to focus as much on syntax and low level nuances, like numeric types, definition / declaration, etc. Teaching embedded electronics (in a manner that allows people to continue easily beyond the basics) can already be difficult enough, as you have to learn both programming and electronics at the same time to people who potentially know neither.

      I dove directly into BASIC when I was very, very young, but I’m pretty sure it would’ve been much more difficult / discouraging if I tried to learn C first.

  18. I still use BS1 (SIP carrier board) and BS2 here and there.. Just too easy to do simple things.. Dozens of them over the years at work in test fixtures (BS2p40 was plenty fast but something like $70 a chip/module) for control before we switched to PSoC 5 or 6 years ago. Most recently a BS2p to decode an analog RC receiver’s servo outputs to use it to control something. Awesome to know they were used in Fifth Element and Star Trek!! What were they controlling……? :)

  19. In mid 80’ies there was Zilogs ZX81 with accompanied bus driver ic, uv-eprom and static ram. Ran everything of an steaming 7805 as it’s current draw was 700 mA. Diy’d a laptop running of D cells. No screen of course but it’s Basic interpreter had something like 80 instructions, so it was perfectly possible to remember your code as typed away in the bus on route to school!
    There was a guy in Sweden back then who programmed it in assembler directly, no high level tools needed.

    The Pic in comparison, was more like a successor to Intel’s 8008 micro processor from the late 70’ies with built in basic interpreter, of course, a lot more capable.
    Can’t help myself giggling when fresh coders complain about i.e. a 16MHZ Arduino not being fast enough. Back then if you were short in raw silicon power you wrote the critical parts of your code in Assembler, compiled it and merged it into your Basic program with special instructions. To my knowledge that kind of manual tweaking is missing nowadays i.e. in Arduino IDE. I’m possible wrong as single Arduino’s control multicopters, so I’d imagine that clever people are doing it still.

    1. C compilers have gotten very good at optimizing code to the point where the compiler can usually generate better assembly than you can, depending on the platform (definitely true for ARM, not so sure about the AVR compiler given that I still do see assembler sprawled about).

      In speed-critical regions, or perhaps more precisely when you need to perform logic that cannot be described accurately yet efficiently with C (for example, exact instruction ordering, etc. which is not guaranteed by the C language) you might need inline assembler blocks.

      I suspect more often assembler blocks are required in Arduino libraries as there is no flexibility in terms of specifying optimization levels to the compiler for individual files. I’ve generally preferred to try to write most functions in C with optimizations if possible, as C is usually more readable, descriptive, and safer than pure assembler.

      Half the things people do with the Arduino these days probably wouldn’t have been possible decades ago, even with assembler optimization. The WS82xx IC would have probably been absurdly expensive by 80s or 90s silicon fab costs, and it wouldn’t have run to nearly as high speeds. Everything was an MPU, not an MCU – i.e. no peripherals like PWM, which you’d probably have to roll on your own in a software loop or more likely a PLD or raw logic chips.

  20. I will take a stroll down memory lane with some others here.

    First job out of school was working for Centroid CNC (http://www.centroidcnc.com/). Their CNC controller back then had Tiny Basic in ROM. This was back in the late 80s, and the Centroid units were being retrofitted to old Bridgeport’s and various Bridgeport clones. So when I saw Makerbits etc., I was a bit “meh .. Literally been there, done that”

    BASIC and FORTH interpreters on embedded boards were plentiful at that time, probably because they allowed.one to interactively “play” with peripherals to work stuff out and they also provided an inherent way to program the device over a serial connection.

    One family of SBCs I have not seen mentioned here are the TattleTale SBCs made by Onset Computing. Great little boards .. Plenty fast and far more capacity than, say, an Arduino Uno.

    There is a certqin power and beauty to the immediacy of an interpreter that is lacking in Arduino and its various couisins, and a well designed interpreter can actually be surprisingly fast (although I did learn 6502 and 8088 assembly precisely to get around speed limitations on Apples and IBM PCs). And, to call myself out as a bit of a hypocrite, I know that there are FORTH and BASIC interpreters for Arduino’s and their kin, but I do not bother with them .. instead, I lazily use the toolchain provided. I do use node.js and python for embedded programming on machines like PC Duino and Beaglebone, so I maybeprices more sloth than hyoocrite.

    In some respects, it’s surprising how little “hobbyist” embedded computing has advanced in the last 20+ years. It has changed plenty, but it seems to have meandered quite a bit .. And this lack of advancement seems more a social network effect than a technological issue. There are ultra-powerful boards available out there at unbelievably low prices (e.g. a beaglebone green will crush an Arduino MEGA by any measure, and is less than half the price), but they do not seem to get as.much love as one might imagine.

    1. Whats really interesting is the Prop 2 v2 that is nearing FPGA-image completion.

      16x 100 Mips Cores
      512 32b Word RAM as Code/Data/cache/Registers
      256K Main memory shared as a Hub, which should be able to run at almost Cache speed
      All Pins IIRC will be ‘Smart Pins’ with built-in ADC, counters, etc.

      Most importantly, Chip has seen the light, and incorporated basic Interrupt/ISR functionality into each Core. For those that understand how easy non-interrupt programming can make things, that is still there, and for those who blew-off the Prop1 for not having interrupts, now it will.

      One downside IMHO, is that some basic h/w peripherals were not added. Not everyone is comfortable or wants to have to worry about ‘software-based peripherals. On the flip side, most of the common UART, I2C, etc soft-h.w is available, as is AES, IR, Nordic nRF2401, SPDIF Out, CANbus, etc.
      Pick the 3,4,5 interfaces you need, and you still have 11-13 100 Mip 32-bit Core available.

      Won’t beat ARM on price, however is going to be a mighty powerful uC that should allow some pretty complex designs to be built with a more RAD-type build since you can avoid interrupt planning/troubleshooting in many cases.

  21. Hi Jeff, Chuck….

    The PIC16CXX programmer contained “ALT-I” functionality which allowed

    a PBasic pgm the PBASIC interpreter to be loaded into a PIC16C58.

    Which would run at 20MHz – 4X faster than a BS1. Later versions of the ’58

    run at 40 MHz, which still looks pretty good for some apps.

    Just sayin…

  22. I have about 6x unused BS2 ‘chips’ in my parts bin… leftover from a project I did back in the late 80s
    The big deal back then was no interrupts – everything had to be polled.

    1. Yes, the PicAxe is a much better deal all around and cheap enough for almost any low budget project. Something you can’t say about the BasicStamp which is still priced in rip-off territory and lacking a lot of features found in the PicAxe product line.

      You want to see price gouging go check out the price of a BS-1 – they are still selling it at $30.

      Still at the time of their introduction, they were pretty innovative. It’s just too bad they let that product line languish and others over take them.

    2. Not exactly a PIC fan, but I can certainly agree that Parallax prices have always been ridiculously high. That and their choices of languages; their BASIC is a true abortion, and Spin is even worse.

      I really don’t get all the fanboi love they get.

  23. The optical monochrometer (400-700nm) that I built back in the mid-90’s, uses the Stamp as controller. Still works great. The Stamp interfaces to a hand controller with buttons / LED readout in nanometers; and controls a microstepper motor drive inside the case.

    Thanks for the great article and comments. Very cool to see there is still support for this workhorse. :-)

  24. I remember the stamps but I bought their (Parallax) PIC-PGM kit. I was copying the idea but each would have a specific function like one with a motor driver, one with touch sensors, etc.

  25. It was great to find this topic here. I started with the BS2 more than 20 years ago and recognize some of the posters here. It was a great rapid development program which helped me win many projects simply because I could create a POC or demo for investors in a fraction of the time compared to my competitors. Some designs could justify the cost of the BS2, thus they remain in a number of my designs to this day. When the cost couldn’t be justified, it was fairly simple to migrate a design to a PIC and port the code over to PICBASIC Pro. If interrupts were needed, that was the time to add them.

    One design I enjoyed doing was a high pressure mixed gas filling station which AFAIK is still used to service 90% of corporate jet aircraft on the planet. This design uses a custom PLC with a BS2P at it’s core, it’s hardened by a bunch of opto-isolators on it’s inputs. Integrated Brownout protection helped support a requirement for failsafe design. Even the individual pressure sensors it uses went from POC to design the same way- moving to 18F PICs for speed and resolution. (I have to credit “Doc” Tracey Allen of EME Systems with figuring out how to do 32 & 64 bit amazing math in PBASIC – Talk about someone who designed and built hundreds of scientific instruments with Basic Stamps!) It ran with a companion set of VB6, then later on, VB.NET programs on an AT PC with a 15″ touchscreen. All the data and fill “recipes” was maintained on a web server which is also used to D/L updates for recipes, the PC applications and Stamp code.

    I still believe the Basic Stamp line provided the quickest route from POC to a marketable product – and this may still be true.
    I pulled one out of mothballs a few days ago to start a Bluetooth project where I have it connected to an HC-06 (which is how I found this site and topic full of fun posts!) Again, it’s the fastest way to get from idea to working demo or concept.
    As a Dev platform, the Graceys knew this, thus there was no reason to make them any cheaper.

    Chip would be thrilled to hear that two generations have followed me into embedded and software engineering, a daughter and more recently a grandson who was introduced to it at one of the “maker” events.

  26. I was an early BS convert & in the mid-late 1990s used them educationally to very good effect. BS modules however were bulky & costly,& the arrival in 2002 of the UK sourced single DIP “PICAXE” family (at prices near an order of magnitude less) pretty much blew BASIC Stamps away. PICAXEs (which use a similar inbuilt BASIC) themselves now struggle against the likes of the many recent educational offerings,some of which (BBC micro:bit etc) feature inbuilt sensors, displays & BT wireless.

  27. To people asking if anyone still uses this, the answer is yes. Long beach state university EE department still uses this for our control systems lab. We use the modern version of course, the board now costs 70$ I believe. We use PBasic (or BASIC Stamp) to program it and use StampPlot to do data acquisitions.

Leave a Reply

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

WordPress.com Logo

You are commenting using your WordPress.com 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

This site uses Akismet to reduce spam. Learn how your comment data is processed.