Powered machinery started the industrial revolution, and it was automation that kicked it up another notch in the 20th century. The ability for machines to make things by themselves spurred increased output and in turn boosted economic growth. The concept became widely popular for manufacturers to implement, as any change with serious economic benefit tends to do. Fast forward to today, and advanced robots and fancy machine vision systems running on powerful computers are the norm in modern factories which create the many wonderful products that we all purchase, use, and enjoy.
Once upon a time, though, things weren’t so sophisticated. [Nicola Cimmino] came to Hackaday Europe 2026 to tell us all about a remarkably simple 1-bit CPU that used to run factories.
Logic, But Make It Cheap!
Nicola Cimmino used to frequent a facility that used to recycle electronic waste, which sold old bits and pieces of hardware by the kilo. Many times, Nicola would pick up odd boards with an eye to repurposing components for future projects. Eventually, one unremarkable looking chip caught his attention—the Motorola MC14500B. This chip was rather unique, being a rather simple processor with just 16 instructions and a 1-bit data bus.
It’s worth examining the era in which this chip existed. Intel dropped the 4-bit 4004 in 1971, with the famous 8-bit 8080 landing in 1974. The Zilog Z80 came along in 1976, similarly an 8-bit design. And yet, when Motorola released the MC14500 in 1977, it landed with a rather slimline 1-bit design instead. Nicola notes that this likely came down to price, since populating a chip with more transistors cost more money quite significantly back in the 1970s. If the job could be done with less, it would make the part cheaper and thus more popular in the market. Bearing this out, Nicola explains that a 1976 Zilog Z80 used 8,500 transistors and cost around $200 USD, while an MC14500 used just 500 transistors and could be had in 1977 for the bargain price of just $5 USD.
Back in the mid-1970s, automation in industry often consisted of simple logic that was handled by cabinets full of relays. This took plenty of bulk, required hard-wiring everything, and also involved plenty of electromechanical parts that could wear out. Changing logic required manually rewiring things which could be fussy and tedious at the best of times. In those days, the Programmable Logic Controller was just coming into use, developed to be a reprogrammable system for industrial automation tasks that was more flexible and reconfigurable just by reprogramming it.
The MC14500 sprung up as a useful tool at this time, powering a great many programable industrial systems. It was designed to offer the bare minimum requirements for its application, while leaving extraneous hardware for designers to implement if and when it was needed. The architecture is simple enough for Nicola to explain with a single slide. The chip came with a 1-bit logic unit, operating with a result register, a 1-bit accumulator and the data bus. A minimal system could be lashed up with the MC14500, a counter, some external RAM or ROM (since none was onboard), and an input decoder and output latch of 8 bits each. This setup would only allow for doing combinational logic, since there is nowhere to store the current state of the system. However, hooking some outputs back to the inputs could allow for sequential logic, since it would allow for storing the current state of the system via those outputs. Nicola then steps through various other configurational changes to addressing and system architecture that could be made to optimize the MC14500 for use in different ways.
If you wanted to get to grips with using an MC14500 in industrial contexts, you would do well to pay attention to this talk, even if it came out some 40 years past the part’s heyday. Beyond the basic system architecture, Nicola explains how to use the limited instruction set, and how to get such a system executing simple programs in ladder logic, which remains somewhat of an industrial standard to this day. Beyond that, he steps up to more complex logic, like if/else conditionals and the use of some of the weirder instructions of the chip. He then shows off the hardware he built himself—both a breadboarded MC14500 setup built with wirewrap, and a more polished version on a custom PCB.
It’s not every day you get to learn about the nitty-gritty details of working with industrial hardware from the ground up. And yet, that’s exactly what Nicola brought to Hackaday Europe 2026. It’s an excellent primer on the topic, and also simply just good fun if you’re a fan of electronics and logic itself!
Follow-up topic, for those not aware of them: bit-slice ALUs and processors built around them.
Yes, I straight away thought of AMDs 29000 series chips. I worked on a mainframe designed with them.
Ah, the good old days.
“Intel dropped the 4-bit 4004 in 1971”
Intel released it 1971 and didn’t drop it until 1981. This isn’t the latest Taylor Swift album.
The Tortured Programmers Department
Didn’t the 4004 have ‘part working’ versions where there was a fault on the die and only a few bits worked properly? I don’t know if this apocryphal, but washing machines could still use them, they had 4 versions of the program in the ROM that worked with the working bits.
That’s ridiculous. In 1971 you could probably get more than ten luxury washers for the price of one 4004 system. Besides that, a partially working 4004 would still be a dead 4004, there’s no way to snip off a dead core because there is only one. And anyone thinking about a ROM four times larger than necessary would have received a healthy spanking.
Actually, half-dead memory chips like the 2704 were a thing. All manufacturers did that to increase yields.
And old cycle timing mechanism in an appliance of that era would have been some stamped steel plates known as a cam stack. Way cheaper than silicon, and only a handful of relays to interface a motor, pump, value, and solenoid.
No doubt that Intel could have done floor swept parts for special vendors. But industrial controls in smaller volumes are more likely for the potential scenario you described. Maybe a missile where nobody cared about cost or long term use.
I read ‘drop’ as in ‘to drop a record’, i.e. slang for releasing a record. Or in this case a CPU. But English is my second language, and so (rap) music slang is quite prevalent in my English vocabulary. :)
No, you’re right and interpreted it the way the author intended. Richard is being pedantic and contrarian.
in late 1977, i demoed a breadboard design using the 14500, sram, & eproms for the greenville area computer club. an arden cutler hammer engineer from the plant up the road from mine asked for schematics which were provided. a few weeks later, he called to ask for some debugging help. they had made pcbs for my design & had introduced errors, in a design already running several pipe hydraulic end forming machines. no credit or $ but a fun thing to design, build, & run. :)
It’s called combinatorial logic, not combinational. The term comes from Combinatorics, a Math branch.
In recent days I’ve seen even HDL people calling this combinational, which is really sad…
Combinational and combinatorial logic are two distinct fields of logic. The use of “combinational logic” in this article is correct.
While having a 1-bit data-bus, the opcodes are still supplied via a 4-bit bus.
Jiri took it to an even further extreme, and built his own a-bit TTL CPU that really only has 1-bit serial bus to FLASH and RAM.
It was discused here a while ago: https://hackaday.com/2023/08/20/only-8-chips-make-a-cpu/
https://www.jiristepanovsky.cz/project.php?p=23cpu
I hope pins didn’t bend.
Around 1977/1978 I created a lift control (elevator control for you on the other side of the pond) with the MC14500.
The basics were two sets of limit switches at top and bottom, one at each end to indicate that end had been reached and one a bit further out that cut power to the motor, just in case the controller had been doing a bad job; a switch for every floor wired in parallel, i.e. indicating that a floor had been reached; door closed indicators; floor buttons; motor controls up/down as well as on/off; and door open/close. The switches were wired redundantly i.e. two independent switches in parallel for each function.
When turned on, it would start recalibrating by moving the car down until the bottom limit switch was reached, now knowing where it was. Then it would count the floors up and down by the floor switches and definitely stop when a limit switch was reached.
There were two slight oversights in the demonstration version that compounded to potentially cause an accident, one software and one hardware. When power was turned on, the software did not check whether the door was actually closed or not, it just started the car going down to recalibrate … Oops! And the hardware problem was that the door switches were not connected to the motor, so an open door would prevent the car moving … Ooooooopppppssss!!!
I got a picture in my head of an old person in the middle of stepping into the car and a power surge initiating the recalibration at the same time. 😱
In the end we added a small battery backup to the controller to prevent recalibrations in case of a surge.
It’s amazing there have been so few injuries over the decades. A lift/elevator is a big heavy machine that people carelessly wander into multiple times a day.
Thank you for putting in the effort and care to avoid guillotining us between floors. A bit like when I cut veggies on a mandoline.
I played with GEM80 https://www.automation-academy.uk/gem-80-plc-systems-and-programmers/ which was obviously years ahead in power with it’s 8-bit system! The factory had just expanded it and wanted me to commission it, in 1998!
You make it sound exotic or complicated but it’s just a simple ASIC to implement ladder logic.
The HDL is trivial to write. The logic is a bit more involved to get right but not too bad. Taping out and manufacturing it at volume in the 1970’s is the true art.
That said, I would love to see this architecture in a future Tiny Tapeout project.
In the mid eighties I started working for a company (my first job) that made machines for the tiles industry.
Commercial PLCs were too slow, so the first generations of their machines had hardwired logic (not with relays but with 74xx logic gates).
Then they developed an in house plc (the one I used), called “prog2002” that had 1 bit accumulator and the same instruction set as the one described in the video, however I don’t think they used the mc14500, it had much more than 8 input/outputs and you could use unused inputs (or outputs, I don’t remember) as temporary storage without the need to wire them.
The way to write a program was to first design a logic circuit then translate it into instructions. Programming was hell you had to use a programming suitcase with a small keyboard, a one line display, a printer and a microcassette player where you could store the program(IIRC).
I remember that the program could be up to 1024 instructions (with a guaranteed cycle time of 4ms) but one of my first programs was over 1100, so I had to “optimize” it by using techniques that were frowned upon (i.e. avoid reloading a value you knew it was already in the accumulator), I reduced it 1020 or something so I had still a couple of instruction to spare in case I had to correct it while testing.
For more complex tasks (that could run at 20..40 ms instead of 4) they also had a system based on the tms9995 that was programmed in pascal and it was a joy to use compared to the prog2002.
In today’s “Believe It or Don’t!” we travel to the UK of the last century where this tech was the basis of the first British smartphone
–the “i-say!”
Nobody mentioning Usagi Electric’s UE-1? Which is a vacuum tube computer based on the 14500. Basically a discretely built 14500, but with a slightly modified ALU. Great stuff, amazing project. Not very practical, but that wasn’t the point. :)
https://www.youtube.com/playlist?list=PLnw98JPyObn0v-98gRV9PfzAQONTKxql3
https://github.com/Nakazoto/UEVTC
https://github.com/Nakazoto/UETTL
I agree. I don’t know how many people in modern times would care about the 14500, with Usagi Electric.
Company I worked at used this 1-bit cpu to control the log cutting saws on the chain line of a local sawmill in 1977, (I miss those days, now even your garden variety iphone has more computing capacity than a cray supercomputer of that era), imagine what technology we will have in 10 or 20 years !!!
Wow, a blast from the past. We used these in our electronics module for my physics degree back in 1983/4 in Liverpool. I thought it was a fun device to use. :-)
“The Zilog Z80 came along in 1976, similarly an 8-bit design.”
Technically, it had a 4-bit ALU, so instead of proofing the point that it had to be at least 8-bit at that time, it kind of disproofs it.
The 4004 -> 8008 & 8080 seems like a steady increase in the number of bits, but PDP-11 was 16-bit and came before them (and earlier architectures were 12-bit, 18-bit etc.).
Then, in 1975 AMD Am2900 bit-slice architecture was released. Being 4-bit, it allowed combining any number of chips to create your own bit length, i.e. 16-bit systems with 4x Am2900.
Still have the manual around here somewhere for the software. No chips unfortunately.