14

I've just finished reading Charles Petzold's book, Code: The Hidden Language of Computer Hardware and Software. In it Charles explains building relays into gates, gates into logic components, and logic components into computing machines.

He talks about the book TTL Data Book for Design Engineers which first came out in 1973. (I'm assuming people had lists of TTL gate chips prior to this). This talks a lot about the Texas Instruments 7400 series of logic gate chips.

Then he talks about the Intel 4004 in 1971, and the 8008 in 1972, the 8080 in 1974 and the Motorola 6800 in 1974.

Could there a homebrew computing club in 1971? Could people have wired together logic gates to build a CPU prior to the 8008 coming out?

(I'm assuming this is people outside the Intel design office who are prototyping the next CPU).

My question is: Were people building CPUs out of TTL logic prior to the 4004, 8080 and the 6800?

Edit: Assumption: By "people" I mean any hobbyist or engineer who is not explicitly prototyping the next CPU to be manufactured by Intel or Motorola.

  • 4
    Side note: if you're a developer and you've never read the book mentioned, you owe it to yourself to do so! – Matt Lacey Jan 4 '17 at 4:25
  • 2
    I wish I could find this great photo that was an article header in Byte ... I think ... it showed a TTL version of a 6809 (possibly a 6801 or even a 6502) that was produced by the engineers designing the chip for testing the thing ... an incredible number of small breadboards (with a few TTL chips each) wired/held together with patch cables ... and the whole thing (which would have been about 10 feet square) just spilling off the lab table ... – davidbak Jan 4 '17 at 6:15
  • 4
    I worked at Honeywell Marine Systems Division, West Covina, CA, part time while in school, 1976-1978 - they were building a sonar for the Navy - can't remember the model number - but it contained a pretty capable minicomputer built entirely out of dozens of 3"x4" modules of TTL logic on a relatively large backplane. They didn't call it a computer though - they called it a controller. Reason was that the Navy permitted only certain milspec computers to be used ... for whatever reason Honeywell didn't want to use one of those ... so they did a homebrew ... but couldn't call it "computer" ... – davidbak Jan 4 '17 at 6:20
  • 1
    This may be a bit OT but several people TODAY are building CPUs out of TTL logic. I even have a design for one though I've never found the time to actually do it (instead I built them virtually in a simulator: yes, one gate at a time - thank god for copy-paste). Google for the "homebrew CPU webring". Why build them instead of buying CPUs? Some of us want to design instruction sets instead of computers. – slebetman Jan 4 '17 at 8:33
  • 4
    Not an answer, but related: A 6502 built from discrete transistors: monster6502.com – tofro Jan 5 '17 at 15:15

10 Answers 10

13

Here is an homebrew / educational computer made of LSI / MSI chips :

http://www.kenbak-1.net/index.htm

Designed in 1971

256 bytes of memory made of MOS shift registers.

  • 6
    Welcome to Retrocomputing! This is a borderline link-only answer. It would help future visitors if you edited your post to elaborate on the KENBAK-1 Computer. – JAL Jan 4 '17 at 21:42
  • 1
    That's awesome! Can you add an explanation of what it is capable of? – hawkeye Jan 5 '17 at 0:46
  • That's absolutely brilliant! I didn't realize so large delay line shift registers were available so early. That's a real computer, made from TTL chips. The complete schematics is in the Theory of Operation document from your link. kenbak-1.net/index_files/Theory%20of%20K-1.pdf . What a treat. Must investigate further. +1 from me. Cheers! – PkP Jan 5 '17 at 7:01
  • Any idea what other sizes of delay shift register were available, either static or dynamic? I would think it would be possible to double the speed of the machine if the program counter were stored in a 128-bit shift register, and bytes were stored in interleaved fashion. If the the longer shifter held address 000[octal], 010, 020, to 170, then 001, 011, 021, up to 171, etc. then instead of each instruction fetch requiring a full lap through the long shift register, eight fetches could be handled on each lap. – supercat Jan 5 '17 at 22:09
  • I agree with @JAL. I'd be happy to upvote your answer if you provided more detail. – CJ Dennis Apr 27 '18 at 1:57
15

Hmm, an interesting question to be sure. It certainly would have been possible to make something like a 4004 style microprocessor from TTL chips. In fact, when Intel made their microprocessor, the first in the world, they chose not to pursue a patent for it, because they felt that there was no invention there; it was obvious for someone to go and combine the workings of a processor from several ICs into a single IC.

That said, it would have been rather pointless for the home enthusiast to make a processor, because before the microprocessor there also were little or no semiconductor memories that he could program with the code that the processor runs. It's rather an unfulfilling excercise to make a stored program computer when you don't have a memory to store the program into. [Edit]: semiconductor memories were becoming available just prior to the microprocessor, and seems there was a time period when this was actually happening, please see the answer regarding the KENBAK computer!

Instead, people were using TTL chips much like programmers are using programming languages today. If you're making a controller for your model railroad, you'd pick a latch here and a flip-flop there. You'd pick up a monostable multivibrator instead of calling Delay(). The hardware design approach worked very well and people were blissfully unaware of the problems and complexities that would later come with software projects.

Building computers was a large industry in the 1960's. But the processor was not the main design problem in those computers, it was the interface to memory. It's rather more difficult to use something like a steel drum memory, even if it couples with a standard 1/2 inch shaft 6000 RPM electric motor, than, say, an EPROM.

Along with the 4004 microprocessor, Intel made also the companion chips 4001, 4002 and 4003: a 2Kbit ROM, a 320 bit RAM, and a 10 bit shift register that works as an interface to the outside world. Without the 4001, 4002 and 4003, the 4004 would have been as useless as the home TTL processor. More info: http://www.intel.com/Assets/PDF/Manual/msc4.pdf

Interestingly, the 4001, 4002, 4003 and 4004 all were the brainchilds of a single man, a young design engineer at Intel, Federico Faggin. He was the lead engineer on all four and, even with one failed production run, he managed to make all the four chips in just 9 months. So I think those chips should be called his brain quadruplets!

Faggin is an interesting man, to be sure. Even younger, before coming to Intel, he also invented the self aligned silicon gate: the single most important IC manufacturing key technology after photolithography. He's still going strong and his interview from 2014 is one of the more interesting views in YouTube: https://www.youtube.com/watch?v=hugZii_eX30

  • 1
    Welcome to Retrocomputing. This is a good answer; thanks for not just explaining whether it was done but why, then how the 4004 was created. – wizzwizz4 Jan 4 '17 at 8:06
  • 1
    Could you explain why memory is a problem? Can't you just build a large array of TTL chips into a makeshift addressable RAM? – hawkeye Jan 4 '17 at 12:47
  • @hawkeye, Hi! well, yes and no. My data book library is in storage, but I'll make a note to dig up a data book from 1970 or 1971 to check what was available. You could perhaps get a register of 8 bits in TTL (74S373) in 1970. But the fan-out of those TTL chips was not too great, meaning that you couldn't connect too many of them together. Perhaps 10 or so. So you could build a RAM of 8 or 16 bytes this way, and people did this, but anything larger would cause design issues of their own: extra amplifiers, darlington drivers, stuff like that to be able to drive a lot of ICs acting in parallel. – PkP Jan 4 '17 at 20:03
  • 1
    @PkP: Did fan-out limitations apply to three-state or open-collector outputs which were not used as inputs? I would have expected that while inputs would source current by design, the outputs of a disabled 74373 should behave as an open circuit. Also, I'm curious if you know to what extent any notable designs made use of what I call "resistor priority logic"--have an input connected directly to a 3-state output and also connected to some other output via resistor, so that the 3-state output will control the state of the line when enabled, but the resistor will control the state otherwise. – supercat Jan 6 '17 at 23:13
  • 1
    @PkP - not a 74-series, but Intel's 3101 was a 64-bit TTL SRAM (16x4 organisation), available in 1969, as was the 1101 which was 256-bit, but PMOS rather than TTL (I don't have a source for its organisation, but it's in a DIP16 package, so allowing for VDD and GND pins plus CS and WE there are only 12 pins to play with, so 32x8 is out of the question, therefore I'd guess it was a 64x4 chip). Along with an 8-way multiplexer chip to run the chip select lines, it should therefore have been reasonably simple to go as far as 128 words. – Jules Feb 15 '18 at 17:27
11

The Xerox Alto

A 1972 machine, officially introduced in March 1973. It had multi-chip CPU built around the 74181 IC.

The 74181 represents an evolutionary step between the CPUs of the 1960s, which were constructed using discrete logic gates, and today's single-chip CPUs or microprocessors. - Wikipedia

The Xerox Alto had a mouse-driven GUI (yep, a real bitmap graphics display), Ethernet (yep, this was the computer they had to invent Ethernet for, to allow to easily put them into a LAN), featured WYSIWYG (they specifically invented the laser printer for that feature) and an object-oriented operating system/development environment. Not too shabby for a personal computer (the first Personal Computer, actually) with a CPU built from discrete ICs.

Note that the Xerox Alto was not the first with a CPU designed around the 74181, it was just the most influential.

Before the 74181 was available, most CPUs would span several PCBs. With the 74181, a CPU could fit onto a single (large) PCB.

Links:

  • 1
    It's also worth noting that while the Alto was actually a relatively slow computer (0.3 MIPS, which is probably roughly comparable to a 1MHz 6502 e.g. Apple II / Commodore PET) this isn't because its CPU was that slow: the CPU was slowed down to 5.8MHz in order to run synchronously with its RAM. Without that limit: a look at the schematic suggests that the limiting critical path would be decode time on its microcode prom (50ns) + about 5 74S series gate delays (typically 3ns each) + either ALU delay (30ns) or register select delay (35ns), so I suspect it could have run at ~10MHz. – Jules Feb 15 '18 at 16:51
  • 2
    I'm glad to see the Alto mentioned here. I'll just add that the Alto's CPU spanned three circuit boards: an ALU board, a control board, and a control RAM (i.e. microcode) board. – Ken Shirriff Jan 4 at 20:07
10

It was very common to build CPUs out of TTL logic prior to the 4004, 8080 and the 6800. This was the standard way to build later minicomputers. Examples are the Data General NOVA, Xerox Alto and TI-990. Also, if a company needed a processor for, say, a CNC machine or a video game (Vectorbeam), it wasn't unusual for them to build a unique processor from TTL.

One interesting case is the Datapoint 2200, a desktop computer from 1970. It was built from TTL parts, originally using a serial processor and shift-register memory. To improve performance, Datapoint asked Intel if they could build a single-chip version of the Datapoint's processor. Intel agreed, eventually building the 8008 processor, which duplicated the Datapoint 2200's architecture and instruction set. (Among other things, this is why x86 is little-endian.) Texas Instruments also built a microprocessor with the same instruction set for Datapoint (the TMX 1795), beating Intel, but ended up abandoning the microprocessor. Datapoint decided to use a faster TTL processor based on the 74181 instead of using the 8008, so Intel marketed the 8008 as a product, essentially creating the microprocessor industry.

To answer your other question about why homebrew computers weren't a thing in 1971, it was basically a matter of cost and complexity. Building a computer from TTL was much too expensive for the typical hobbyist, and much more difficult than building a computer from a microprocessor chip. As someone else mentioned, memory was also a huge problem. Magnetic core memory was the only cost-effective approach, but it was expensive and required complex interfacing. Semiconductor memory was insanely expensive at the time: Intel's first RAM chip came out in 1969 and provided 64 bits of storage for $99.50.

To summarize, CPUs were commonly built out of TTL logic, but these were minicomputers, not hobbyist computers. It wasn't until cheap memory and microprocessor chips were available in the mid 1970s that homebrew computers took off.

  • 2
    This is a very informative answer. Thanks for sharing! – wizzwizz4 Jan 4 at 22:09
  • 1
    Great answer! One question "Intel agreed, eventually building the 8008" - how does the 4004 relate to this part of the story? Isn't the 8008 just the follow on from the 4004? – hawkeye Jan 5 at 0:46
  • While the 8008 is often described as a follow on from the 4004, they are in fact totally different processors. Many of the same people worked on the 8008 after designing the 4004, but otherwise there is no connection between them. – Ken Shirriff Jan 5 at 0:57
9

It would have been cost and space-prohibitive to try to build a microcomputer using TTL logic chips, but minicomputers and mainframes were routinely built from such chips (or related technologies like DTL, ECL, etc.). Processors like the 4004, 8008, 8080 and 6800 were not powerful enough for minicomputer and mainframe workloads, so they used simpler (and faster) chips to get the job done.

Eventually minicomputers and mainframes were able to fit the entire CPU onto a single chip, but until then it was common for CPUs to occupy one or several circuit boards (or a cabinet full of circuit boards). Large chips like the AMD 2900-series allowed processors to be reduced from a cabinet down to just a few boards.

  • Thanks Ken. Can you help me understand why the distinction between microcomputer and minicomputer was important when building a machine without a CPU on a chip? – hawkeye Jan 4 '17 at 12:51
  • 1
    The distinction is primarily about size and cost. A microcomputer could be expected to use a 4-bit (4004) or 8-bit word size (8008, 8080, 6800), with a fairly small amount of memory (as little as 1KB) and few or no peripherals. A minicomputer would be expected to have between a 9-bit to 18-bit word size, a minimum of 4KB memory (preferably 8KB or more) and at least a few peripherals (teletype, paper tape reader/punch, etc.). Just for the CPU logic by itself, a 16-bit mini would use 4 times as many TTL chips as a 4-bit micro, making it 4 times the size and 4 times the cost. – Ken Gober Jan 4 '17 at 14:14
  • Wow! Minicomputers used a 9 bit word size? What was the non-CPU chip a mini computer used that was easier than combining TTL chips? – hawkeye Jan 5 '17 at 0:51
  • 2
    I don't know of any that actually had a 9-bit word size, it's just a boundary to separate the larger-word-size minis from the smaller-word-size micros. I know that 12-bit, 16-bit and 18-bit word sizes were common, and there was a 10-bit computer at Lincoln Laboratory. Minicomputers did eventually use TTL chips, but because of the larger word size the number of chips needed was higher, and as a result the size and cost of the computer were higher as well. Before TTL they used discrete transistors and diodes, not because it was easier but because TTL wasn't available in convenient packaging. – Ken Gober Jan 5 '17 at 13:36
  • 1
    At that time, you couldn't really make a CPU with fewer than several dozen chips unless you were using MSI chips that implemented larger features like ALUs, register files, ROMs, etc. in single chips. When LSI chips became available, it was possible to build an entire minicomputer CPU in one chip (or a few), and the distinction between minis and micros shifted away from CPU size and towards things like word size, address space, and I/O capability. Modern mainframes are now the size of old minis, and modern minis are now called "servers" and use CPUs nearly identical to the ones in micros. – Ken Gober Jan 10 '17 at 4:41
8

There was also the EDUC-8 (pronounced "educate"). It was Australia's first hobby computer, published as a series of articles in Electronics Australia from August 1974 to August 1975. The computer uses 100 discrete logic integrated circuits. There are 98 74 TTL series or 9000 series TTL chips, and two 1Kx1 static RAM chips. The computer runs at 500 kHz, with a 10 kHz instruction rate, due to bit-serial implementation to reduce complexity. There is an option of 128 or 256 bytes of RAM. Instructions are manually loaded using front panel switches. There are two serial input ports and two serial output ports at the back of the computer. These can be connected to a keypad, octal display, paper tape loader, paper tape puncher, printer, keyboard, music player, teleprinter, magnetic tape recorder and alphanumeric display. The 8-bit instructions are based on a shortened version of the 12-bit PDP-8 minicomputer.

The computer uses a custom power supply, supplying 6A at 5V (30W total) to the computer and peripherals. The computer uses 3A (15W) with the peripherals using up to 3A. The main computer is housed in a 103 x 293 x 357 mm case. There are eight single-sided printed circuit boards consisting of the Front Panel Board, Connector Board, Timing Board, Decoder Board, Accumulator Board, Program Counter and Adder Board, Memory Board, and IOT Interface Board.

You can see pictures and read more about it at http://www.sworld.com.au/steven/educ-8/

Alan

  • My Dad had this magazine! So awesome. – hawkeye Jun 5 '17 at 2:30
6

The 74181 ALU was available in 1970, so hobbyists could build something with it -- it was $16.50 in quantities of 100. http://apollo181.wixsite.com/apollo181/about

Here's a 4-bit computer built around the 74181 and TTL logic: http://jaromir.xf.cz/fourbit/fourbit.html

That "thing" doesn't have to be a full CPU though. For example, Midway's 1975 arcade game Wheels II uses the 74181 as a glorified counter which was sequenced by a ROM, but still not technically a CPU -- since it was limited to a few addition operations and no branch instructions, hardwired to the needs of the game.

  • Right. The 74181 is a very versatile component. You can build a CPU with it, but if you already have a CPU available you can use it as a maths coprocessor to handle stuff that's too hard for your CPU. If you can push data to it fast enough, you can get up to 50MHz out of it (or 30MHz if you're using many of them along with a 74182 to produce a 16-bit wide ALU), one operation per cycle. It was to 70s CPUs roughly comparable to GPUs nowadays. – Jules Feb 15 '18 at 17:01
  • In the early days there were a lot of computers which were not Turing-complete. But they were still useful for a lot of things. The defining feature of a CPU would be that it was a somehow "centralized" processor (even if it was huge) which could do many sorts of things. – Klaws Feb 22 '18 at 13:42
5

The German hobby-electronics magazine "ELEKTOR" had a project called "Computer 74", named both because of the year of publishing and the TTL logic chip family that made up most of the design. Sorry, I don't remember more about it...

3

Well, there was an obscure computer called the VAX 11/780 built out of TTL.

This was of course not a hobbyist computer, but it doesn't seem to be ruled out by the wording of your question - it was certainly built by 'engineers'.

On the amateur front, here's a 1975 newsletter from the (UK) Amateur Computer Club, containing details of a machine called the Weeny Bitter, constructed with 7400-series TTL. I was vaguely considering building it at the time, but never did.

1

Perq computers, which were built first in Pittsburgh, PA, and then later, somewhere in England, had a CPU that was mostly built from 74LS parts. "Mostly," because it had one LSI chip, an Am2910 microsequencer.

The first Perqs were shipped in 1980--well after the Apple][ and other microprocessor-based computers had hit the market. In fact, the Perq's I/O system used a Z-80 as an auxiliary processor.

  • More details, including photos of the CPU and IO boards, here – Jules Feb 17 '18 at 8:47

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.