Chips Remembered: The Scenix/Ubicom/Parallax SX

If you are a bibliophile, going to a used bookstore is a distinctly pleasant experience. Sure, you might discover an old book that you want to read. But at least some of the endorphin rush comes from seeing old friends. Not humans, but books you read years or even decades ago. Most often, you don’t buy the book — you probably have one stashed in a box somewhere. But it is a happy feeling to see an old friend and maybe thumb through it reading a passage or two among shelves of musty books. I wish we had something like that for chips. Outside of a few notable exceptions, chips tend to have a short life span of popularity and then give way to other chips. This is especially true of CPUs. One that I especially miss is the Scenix/Ubicom/Parallax SX chip.

I had a bookstore-like experience with this processor the other day. I produced a few products based around these chips and I have a small stash of them left. I jealously guard the hardware needed to program them “just in case.” Well, naturally, someone needed a few for some reason so I had to dig it all up. Knowing these might be some of the last of the unprogrammed SX chips in the world made me a little nostalgic.

The Story

In the late 1990s, a company called Scenix started producing a microcontroller called the SX in a few footprint sizes. So the SX18 was, for example, an 18-pin part. By 1999, they were already in full swing with the SX18 and SX28 and they introduced the SX52.

Of course, a lot of companies produced microcontrollers. The Scenix offering was a bit special. In those days, the Microchip PIC was the king of the hill. The PIC is an odd beast that evolved from a very limited controller made to be small and inexpensive. Notably, while it could support relatively high clock frequencies — 20 MHz was common — each normal instruction took 4 clock cycles. So when your crystal said 20 MHz, you were running instructions at 5 MHz.

The SX duplicated the Microchip instructions, but not the opcode mnemonics, since that was legally encumbered. In theory, you could take binary code meant for a PIC and deploy it on the SX. So the device had all the same architectural quirks as the PIC which was both a plus and a minus. However, it did have one huge advantage over the PIC: It could run at 50 MHz for real. The SX used a pipelined architecture so it was able to run one instruction per clock once the pipeline was full (and assuming you didn’t invalidate the pipeline with a jump).

That was 10 times the actual speed of a PIC. Granted, at 50 MHz, the chip drew a lot of power, but you could tune that by scaling down the frequency. Even at 10 MHz, you were running twice as fast as a PIC. Later versions could run at 75 MHz and even 100 MHz, although these were rather quickly discontinued. However, these chips were routinely overclocked to at least 80 MHz in, for example, the XGameStation.

The SX-Key provided programming and debugging over the SX clock pins.

There was another killer feature that seems normal today but was a revolution at the time: cheap in-circuit debugging. Most older CPUs had to have an expensive special part to do live debugging with no extra software on the chip. Sure, you could write a debugger that talked to a serial terminal, but that assumes a lot of things are already working. To do real hardware-level debugging was generally very pricey. But the SX had all the hardware required on every chip. A small serial port dongle that didn’t cost very much was available and with it, you could debug the chip in your circuit with no real impact on your code.

Peripherals Virtually

One key concept to the SX was that the CPU was kept very simple to hold down costs and increase speed. The trend, of course, was to add things to CPUs like UARTs, timers, PWM generators, and things like that. The SX did it differently. Running fast and having a very deterministic way to handle interrupts, Scenix touted a “virtual peripheral” library. The idea was that by using interrupts, you could build software peripherals and even if they ate up, say, half of your CPU time, you were still running many times faster than a PIC with peripherals.

Of course, if that works, it is great because you can tailor all the things you want. Need three UARTs and one PWM channel? No problem. If the next project needs five PWM channels and no UART, you can do that too. Of course, this was always better in theory than in practice. The “library” was little more than some example code and sometimes integrating it into your code was challenging. This was especially true if you were trying to integrate more than one since they would sometimes have conflicting requirements.

Still, you could do quite a few things that would have been almost impossible to do in software on a slower CPU.

The Parallax Connection

Scenix eventually became Ubicom, which would eventually get vacuumed into Qualcomm, but these chips are also associated with Parallax, a company well known for their Basic Stamps which were once the gateway drug to microcontrollers. Their products used the Microchip PIC, and they started selling a line of SX-based Stamps that were pretty much drop-in replacements for their existing products but much faster. (And of course more power hungry.) They also offered the chips and programming hardware they designed at affordable prices making the SX somewhat popular in the hobby community.

A Parallax development board with the SX-Key plugged in.

Parallax also developed books and courses for the chip. (I even wrote some of them.)  A library existed that had code to do many common operations like FSK, I2C, SPI, run LCDs and stepper motors, and a lot more.

By 2005, Ubicom would step away from the SX and sell them only to Parallax with Parallax branding. By the middle of 2009, Parallax announced the end of the road for the SX. These days, you can pick up a 32-bit processor that can run at 100 MHz for a song, and integrated debugging is common. Modern CPUs will have architectures that are a bit saner than the PIC’s old bank-switching scheme and more amenable to C compilers, too. So I don’t miss those old days. But like an old book in a bookstore, it is good to see my old friend the SX.

What old processors are your friends? I’m very fond of the RCA 1802. I did a lot of work on old Motorola devices, too, like the 6805 and the 68HC11. I enjoyed the Basic Stamp, too. I can’t help but wonder if, in 30 years, people will fondly look back at an STM32 device or maybe the Raspberry Pi Pico?

70 thoughts on “Chips Remembered: The Scenix/Ubicom/Parallax SX

    1. Wow this thread is a veritable who’s who from Parallax forums. Good to see all of you gents. I still have a sleeve or two of SX chips when Parallax was discontinuing the line.
      Terry, I still use your USB powered Propeller Mini Development Board for quick development of small projects, it is my favorite dev board for Prop 1.

    1. NEC V30 (enhanced 8086), Z80, Forth Chips Rockwell 65F11 and Harris RTX 2001. Exotic processors like the NEC Image Pipeline Processor, Inmos Transputer, Linn Rekursiv, Viper, and Asynchronous ARM were fun to study.

  1. My first micro was the pic16f84a … still have a decent stash of them somewhere (probably like 20 or 30), untouched and prestine lol. I built a sketchy serial port programmer with instructions I found online. I wrote code in notepad and used a command line compiler. I remember the very first hello world blinky led program I flashed onto one was so magical. I must’ve been like 14 or 15 at the time, brings back some good memories when everything was so fascinating.

    1. I’ve fond memories of the 16F84, too!
      It’s a true classic, along with the older 16C84 and newer 16F84A.

      So many early homebrew projects of the 90s/early 2000s were based on the 16F84! 😍

      And it was fun building little “programmers” for it.
      PICProg had a very simple serial port circuit for it, I remember.

      Even though a battery was highly recommend. Powering of RS-232 never worked reliable for me.
      So I removed the diodes and added a little 9v (?) battery instead.

      To me, the 16F84 was a big part of the Windows 98/XP days of homebrew computing.
      The 16F84 was like the equivalent to a proto-Arduino. Interfacing the 16F84 was so hassle-free by comparison.

      Sure, the Z80 SBCs (known as EMUFs in German) were great, too.
      So were the 1802 boards. Unfortunately, they needed EPROMs to work.
      In the 80s, you could still use a cheap C64 and an adapter on USER port for that.

      But in the 90s and early 2000s, on a PC, you needed to pay a 1000DM for a prommer. Like those fancy Willem programmers for the then-outdated LPT port. A young person couldn’t afford this.

      That was before the arrival of the cheap G540 and TL866 programmers.
      They were years away in the early 2000s.

      8052 AH-BASIC systems could have been an alternative, but sadly that pre-programmed 8051/8052 MCUs with BASIC were already deprecated since the mid-80s.

    2. I started with 16F84 and 16F877 back when I was 12. Had to go to other room to the family computer to make changes and back to my own desk to test. ESD damage claimed an IO pin every now and then, but I just soldered jump wires to substitute another one.

    3. For me it was the RCA 1802. It was circa 1990 when Raytheon won the 2nd source of the Stinger missile from General Dynamics. The Army provide a bunch of schematics for the missile and the Test Equipment. Both used the 1802. Spent one long summer in the basement of the Raytheon Lowell factory with a couple of other guys, bringing up the 1802 based Test Equipment, and then the actual missile front end for another 2 years. Great processor, great GD design, and a lot of fond memories.

    1. Z80 SBCs can be surprisingly simple if you don’t head for CP/M (or NewDOS80v2), floppy disks and such. Just dig a bit. Getting Forth and a Z80 together should be one of the simplest tasks (in EEPROM days).

      If you think needing a 2nd toolchain (AVR) to get your Z80 build up and running is not a showstopper, then look for Z80-MBC and Z80-MBC2 in or here. It really is worth a look. Only a version with even more than 128k RAM seems to be missing…

      If it is just for coding on a small size system, look for the PIC32 TRS-80 emulator in, CPM8266 @ github, RunCPM @ (and github) because some of these µCs really are fast enough to have fun an emulation.

      Emulations on PCs aren’t a bad thing too. Apart from the harddisk you already have, they eat no additional real space and won’t collect dust while unused… ;-D

  2. I’m surprised you left out the major Parallax connection. Chip designed the SX with/for Scenix. Microchip’s legal maneuverings is what killed the SX and they finally just did a lifetime run for Parallax and washed their hands of it. Just the description of “what if we made a better PIC” has Chip written all over it.

  3. That was a nice article, Al. Interesting bit of history. I used PICs back in the day but somehow never heard about the SX chips. I shudder now thinking about the limitations of the PIC I lived with as I programmed in assembly. I got my introduction to computing via the quirky but somehow endearing 1802 because it came on the cheapest board I could find and convince my father to buy for me.

    1. I began with PIC, and was recommended SX28. I bought a couple, but my microcontroller rush ended soon and I never got around to them. SO yes, I have two unprogrammed SX28 too.

  4. Original apple macintosh was a great machine for bare metal assembly language. The hardware was all specified, you could reprogram the timer chip and get decent high precision timing, the Z8530 serial port chip was very versatile, you could use the handshaking lines for GPIO. You could completely bypass the graphics libraries and write pixels directly in the frame buffer. If you really wanted, you could take over everything and do all the io and memory management yourself but you had to exit your program by rebooting the machine.

    68000 assembler is really easy. It is great as your first assembly language experience because it doesn’t have any of the weird cruft you see in Intel assembler.

    Best of all, apple had a free assembler and linker that were easy to use and you could put your entire development environment on one floppy and take it all with you, so you could just sit down at any machine in the lab and go right to work.

    People say “Apple machines were SO expensive” which is true. But the average Mac user spends 3x as much on their computer (counting accessories, software, etc) so they are a much more lucrative market if you want to sell stuff.

    1. I totally agree that 68000 assembly is really easy (I come from a Sinclair QL background). I was first introduced to the Mac in 1986 at the University of East Anglia and it was certainly a revolution. I didn’t know there was a free assembler and debugger from Apple.

      (search for article 487, page 8 of the blogs about MacASM and there are others about MDS).

  5. I remember the oddball Parallax 2. Of course it never existed, but exists at the same time, and seems now definitely buried. The parallax 1 still exists, but i can´t figure out in which parallel universe it is used.

  6. Seeing the DIP ICs poked into the conductive foam in the Title photo gave me warm, fuzzy memories.
    Reading that they were based on PIC flushed those feelings away.

  7. I want extremely simple MCU with low pin count (up to 18 pins), with PIC16/MCS-51/PDP-11/Z80 rinstruction set unning at modern 2-3GHz.

    However, nobody manufacture them. Just like nobody manufacture simple low pin count MCUs with Ethernet peripheral.

    1. It doesn’t make much sense to make that. At 2-3GHz, you’re forced to work at tiny process nodes (22nm? lower?) and at those nodes an 8-bit CPU core is tiny compared to e.g. the bonding pads you also need to integrate. That makes it cost literally nothing extra to dump a larger processor (32-bit RiscV or ARM, for instance, and loads of other stuff) in there, and that more-or-less brings you up to Raspberry Pi-like systems.

  8. My first project fitted 2kB of hand coded machine code into a 6802, including a 24/8 division routine. Development was tricky as all jumps had to be calculated by hand but it did teach me that modular code made life easier. I had lots of fun with my Oric1 (6502 based, running Basic) and then lots of 8031 projects, by that time I actually had access to an assembler!

    1. There was a table, I think in Byte, that gave the offsetvfor branching. So I photcopied it and glued it to a piece of cardboard. Same with an ascii chart. My KIM-1 came with a 6502 programming card, which was rsaloy handy, I still have it, so it made sense to have some other information equally handy.

      The Apple II had a mini-assembler, but it was based on the 6502, so couldn’t be easily changed to a different cpu.

  9. First programming: A TTL trainer with 32 bytes of “ROM” (slide switches) that my father built from a kit in the early 70’s; IIRC it had a 74181 ALU. The only output was 8 incandescent (flashlight) bulbs.
    First microprocessor: CDP 1802 (COSMAC VIP) in the late 70’s. I had it hooked up to a small TV intended to be installed in RVs that I found in a surplus shop.
    First high-level language: IP Sharp APL (lord save me). We sold a “dumb” terminal capable of unlimited APL overstrikes and I wrote demo programs in APL.
    First microprocessor (professional): Z80 starting in the early 80’s. Roughly 128k bytes of code, all in assembler. Yes, you read that correctly – 4 banks of 32k each in 2 27512 EPROMs. A “dumb” terminal compatible with DEC VT220 (and VT52, since VT52 was part of VT220), Tandem 6530 and Tektronics 4010 simultaneously over 3 serial ports, any of which was capable of doing any (or all – you could switch modes at will) of the emulations using any part of 8 132 x 24 pages of memory.
    First microcontroller: Zilog Z8 in the mid 80’s. The one with the Basic interpreter, connected to a speech synthesizer. The above-mentioned terminal on reset could load a small Basic program into it using one of the serial ports, then send it speech phonemes for verbal output. The Basic program and phonemes could come from a host mainframe or could be sent by the terminal itself. We didn’t sell many, but it was fun to build and demo (I could program function keys on the terminal to “say” various phrases). Only 4 chips, not counting the power supply.

    1. That TTL trainer sounds a lot like something I had. My dad knew a guy who went through a correspondence course to get a “certification” but already had the knowledge so didn’t build any of the experiments. My dad ended up dragging home box after box of stuff, including documentations, that kept me off the streets for many months. I wish I’d held onto all of that stuff, but I don’t know where the heck I’d keep it since I’ve collected so much other electronic miscellany over the years since.

      My first real actual “build something” work with a CPU was done with a Z80. Part of my college education required designing and building a system with RAM, ROM, I/O, etc. It was a thing of wire-wrapped beauty (or so it seemed at the time), especially when I added a keyboard matrix from a dead TI-99/4A and a 2 line x 40 character LCD. Those seemed so much more “real” than the hex keypad and LEDs that were available in the box ‘o parts that we started with. All programming was in assembler. In a later term, we had to use the system to do something. I’m still happy with the toy car assembly line I hacked together out of scraps and dirt cheap surplus. It was a genuine pleasure to see the first successful run. Still have a VHS tape around somewhere showing it in operation.

      I scrapped the mechanical bits years ago, but I should plug in the computer to see if it runs. All the wire-wrap got soldered once the control system was stabilized and it’s housed in an old VCR enclosure using the original VCR power supply, so it might still work.

      My first MCU was a PIC. Programmed in assembler. The first actual thing I built with it was a replacement for a deceased MCU in a video game controller. It seemed weird to me that it had the same name as the Programmable Interrupt Controller 8088 peripheral that I’d studied. I eventually figured it out. Generally, if I’m tinkering at this level today, I search out one of the Arduino Nanos I have strewn about.

      1. >> That TTL trainer sounds a lot like something I had. My dad knew a guy who went through a correspondence course to get a “certification” but already had the knowledge so didn’t build any of the experiments.

        That’s exactly how my father got the kit. He was a typesetter (cold type), having started in his teens in his father’s printing shop in Sydney, NS. When the typesetting industry started the transition to phototypesetting in the 60’s my father saw the writing on the wall and took some correspondence courses from NRI/McGraw-Hill and the trainer was part of the Digital Electronics course. The first oscilloscope I ever used he built as part of the Analog Electronics course. His employer paid for the courses, and gave him the job of setting up, maintaining and over the years expanding, the phototypesetters and the DEC PDP-8 (later LSI-11) that ran the compositing software.

        Come to think of it, the first significant work I did with a real computer after that trainer was typesetting my grade 13 (Ontario had an optional 5th year of high school at the time) yearbook on that system, entering the text and formatting commands on a VT52 terminal (and in some cases a Teletype model 33), then loading the resulting paper types and the appropriate font discs into the typesetters to get the film output. That would have been in late 1977 and early 1978.

        1. Oh wow. That sounds like what happened with my dad. He started out in hot metal, Linotype. And then moved along to photo. Although all three shops we were involved in ran on DG machines and output machines made by the company behind that heritage item.

    2. The trainer was likely part of a correspondence course. NRI, or one of the others. Lou Frenzel has written about working for NRI, before moving to Heathkit’s educational division, but really, he got them into computers.

      But he mentioned building a trainer at NRI. And he left in 1973, so it wasn’t a microprocessor. I’m sure I’ve seen the trainer in NRI ads.

      1. I took the NRI Course in the mid-1980s, and waited to get the microprocessor trainer. In fact, I am still waiting, they closed shop before sending it.

  10. Way back in 08 or 09ish, someone on the parallax forums gave away an sx board and book. They ended up with me right before I started university and was my first experience with microcontrollers. I still pull them out from from time to time. Wish I could find that old thread and send them a proper thank you.

  11. My first design used a National Semi PACE — a true 16-bit microprocessor (the first??); instruction set looked like a Data General Nova 1200. Very nice, but S L O W; had a 10µsec major cycle time. When I later did some 8086 stuff, I realized what a POS it (and iNtel) were.

  12. My “old friend” is TI’s msp430. It’s what got me my first job, and I’ve done many a hobby project with them. This also was one of the first with cheap debugging, with the eZ430 and a bit later with the msp430 launchpad for $4.30.

  13. I, too, remember this chip fondly. I had been programming PICs in assembly for a while when I ran into these on the NJQRP’s PSK31 beacon board. That board used one of these with an R2R ladder on one of the 8 bit GPIO ports to generate an audio range PSK31 message which was used as part of the NJQRP’s Atlantacon conference project.

    It seemed like such a waste to use a 50MIPS processor to generate a 1KHz modulated audio signal and I thought it could do better. I ended up with a tight interrupt routine that implemented dual DDS accumulators (one for the carrier and one for the modulating waveform) which ran at 500KHz. The main loop ran in the background and calculated the current modulation word based on the DDS accumulator value from the interrupt routine. All the code as well as the Sine lookup table and the precoded PSK31 varicode signal fit in 256 bytes.

    These were wonderful little chips. Is the software to program them still working? I’d love to go back and play with them as I still have a lot of my original hardware. Thank you for all of your work, Al, I probably used some of your documentation back in the day.

  14. I think my nostalgic CPU would be the AT90S2313 (which now more-or-less is the ATTiny2313). I started with the PIC16C84 as that had EEPROM and I was too young to have proper pocket money for an EPROM eraser, so that was the first microcontroller I could program. It was nice, but the fact that you had to pull everything through the W register was a pain. Then I found out about Atmels stuff, and switched immediately. The programmer was easier to build (just some parallel port wires), the instructions were sane, and holy blazes, 32 registers instead of one!

    Btw, if you allow me to toot my own horn (as I work for Espressif), I feel that the ESP32C3 and -S3 are pretty good about the debug interfaces currently. For them, you don’t even need a small adapter board; you can hook up an USB cable directly to the chip and have a JTAG and serial interface to program and debug the thing.

    1. Hah! I just mentioned the Tiny2313 and Tiny13 as my nostalgic chips (depending on how many pins I need for the trip down memory lane?) in the podcast.

      You wouldn’t think it was such a big deal, but that low barrier to entry was revolutionary. Sounds like Al’s SX chips had a little of that flavor as well, at least with cheap programmers/debuggers. And then along came Arduino…

  15. My favorites are Z80, 6809, and 68000. I even got paid to write 6809 code from ’97-’00.

    My current favorite is STM32 in C/C++, and I still have most of a big bag of Blue Pills that I got when they were mentioned on Hackaday years ago.

  16. CDP1802. Instruction set was easy to learn, orthogonal, and converting it to machine code could be done manually with little effort. A motivated teenager could write an assembler for one if they couldn’t find one. On the other side, the peripheral interconnectivity was low except for composite video and rs-232 and there wasn’t much software. Although recently some new programs have been written for it, usually in chip-8.

    x86? Now that is one complex beast having special purpose registers and some complex instructions.. high level languages ran fine on it though.

    1. Cool! The Cosmac 1802 was also used in orbit in amateur radio satellites (AO-10, AO-13, AO-21, AO-40).
      The non-hardened version, I mean.
      Along with the awesome but now forgotten IPS operating system.

      What’s impressive, the little 1802 could handle a wide range of voltages (about 4 to 10,5v)!
      So even if voltage fluctuated, went down etc. the 1802 was still working correctly!

      1. It was chosen because it was so easy to load new software remotely. It’s the same reason hobbyists like it, no monitor rom needed.

        When the guy from Amsat gave a lecture at our ham club in the late seventies, the fact that the 1802 was radiation hardened was a factor in choosing it.

      2. It was also used in the Galileo, Magellan and Ulysses probes, and the Hubble Space Telescope.

        In addition to being available in a radiation-hardened version, being an all-CMOS design meant it consumed only 4 mA max (20mW @ 5V) at 3.2 MHz. And the all-static design meant you could stop the CPU and reduce power consumption to a typical 1 uA (5 uW) without losing the internal state. By way of comparison, the 8080 consumed 1.7W across its 3 power supplies.

        Power is a bit hard to come by around the orbit of Jupiter, so every micro-watt counts.

  17. Oh man, I remember those, and still have like a dozen or so in a case, plus the dev board and two programming keys. I was barely a teenager when I got them, so I never used them for anything meaningful, but they’re definitely the reason it just feels “normal” for me to write MCU code in Assembly now.

  18. What a joy to discover PIC microcontrollers in the 1990s after struggling with clocked eeproms to carry out sequential logic! I did learn some microcontroller skills on a City and Guilds level 3 course in the 1980s. We had a Z80 on a board with a motor, fan LEDs temperature sensor etc. The problem was it was programmed in machine code so you had to learn the machine code instructions. The exam included a question where you had to provide a program listing in machine code to carry out a specific task. The joy of using assembly language on PIC microcontrollers, so much easier than working in the binary instructions.
    I guess my favourite PIC is the 16C71 as it had ADC inputs but a pain having to use a UV erasure when developing. The 16F84 was so much easier to use by comparison until I had a hardware emulator from RF Solutions. I made my own jumper connections so I could use the emulator for the various PIC microcontrollers but adapt the code as the emulator was for the 16C671 (I think). I even had an 8 pin Dil lead to allow debugging circuits designed for the 12C671 (aircraft low battery voltage warning). Just had to remember to change crucial parts of the header etc when assembling the code for the actual chip.

  19. Hey, I was one of the Applications Engineers working at Scenix in those days. I wrote a bunch of the virtual peripherals including the V.23 modem, tone generation, DTMF generation and detection, multi-UART, SPI, etc… Good times. The SX was a really versatile processor once you got the hang of VPs, honestly. It was very power-hungry, but a modern version running at, say 500MHz on less power on a modern architecture as a co-processor would be really great for hobbyists.

Leave a Reply

Please be kind and respectful to help make the comments section excellent. (Comment Policy)

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