68k

The greatest computer Apple will ever make isn’t the Apple II, it isn’t the Bondi Blue iMac, it isn’t the trash can, and it certainly isn’t whatever overheating mess they’re pushing out now. The best computer Apple will ever make is the SE/30, at its time a server in a tiny portable shell, and capable of supporting 128 Megabytes of RAM thirty years ago.

Over the years, people have extended and expanded the SE/30 to absolutely ludicrous degrees, but now we have a simple way of adding WiFi to this classic computer. Over on the 68kmla forums, [ants] discovered a tiny cheap card that could easily serve as an Ethernet to WiFi bridge. After attaching this card to a Danaport Ethernet card and bending some aluminum for a bracket, they had a WiFi antenna sticking out of the back of a 30-year-old computer.

But adding a WiFi card to an old computer is nothing new — this could have been done with a Pi, or if you’re a hacker, a TP-Link router flashed with OpenWRT. To really do this right, you’ll need integration with the operating system, and that’s where this build goes off the rails. [ants] wrote a WiFi extension for System 7 (with the relevant GitHub)

The problem with the Vonets WiFi card is that configuration has to be done through a browser. Since there are no modern browsers for classic macs, this meant either pulling out a PowerBook or doing the configuration through your daily driver desktop PC. The WiFi extension gets around that by giving a classic mac the ability to configure the Vonets card almost automatically. This extension also looks like how you would configure the WiFi on a modern mac, complete with the WiFi icon in the toolbar. It’s beautiful, and one of the rare examples of modern 68k mac programming.

As for what you can do by adding WiFi to a 30-year-old computer with a 16MHz processor, the answer is a resounding, ‘not much’. Your choice of browsers is limited (iCab seems to be the best), but you can load the Google homepage slowly. HTTPS isn’t going to work, and the Internet right now is full of megabytes of Javascript cruft. If you find a nice, lightweight web page — such as the Hackaday Retro Edition, for example — you’re looking at a capable web browsing machine. Of course, the real use case for giving the SE/30 WiFi is file transfer around the home network, but still: it’s WiFi for the best computer Apple ever made.

This is a tale of old CPUs, intensive SMD rework, and things that should work but don’t.

Released in 1994, Apple’s Powerbook 500 series of laptop computers were the top of the line. They had built-in Ethernet, a trackpad instead of a trackball, stereo sound, and a full-size keyboard. This was one of the first laptops that looked like a modern laptop.

The CPU inside these laptops — save for the high-end Japan-only Powerbook 550c — was the 68LC040. The ‘LC‘ designation inside the part name says this CPU doesn’t have a floating point unit. A few months ago, [quarterturn] was looking for a project and decided replacing the CPU would be a valuable learning experience. He pulled the CPU card from the laptop, got out some ChipQuick, and reworked a 180-pin QFP package. This did not go well. The replacement CPU was sourced from China, and even though the number lasered onto the new CPU read 68040 and not 68LC040, this laptop was still without a floating point unit. Still, it’s an impressive display of rework ability, and generated a factlet for the marginalia of the history of consumer electronics.

Faced with a laptop that was effectively unchanged after an immense amount of very, very fine soldering, [quarterturn] had two choices. He could put the Powerbook back in the parts bin, or he could source a 68040 CPU with an FPU. He chose the latter. The new chip is a Freescale MC68040FE33A. Assured by an NXP support rep this CPU did in fact have a floating point unit, [quarterturn] checked the Mac’s System Information. No FPU was listed. He installed NetBSD. There was no FPU installed. This is weird, shouldn’t happen, and now [quarterturn] is at the limits of knowledge concerning the Powerbook 500 architecture. Thus, Ask Hackaday: why doesn’t this FPU work?

We’ve been lurking over at Big Mess ‘o Wires as [Steve] geared up for his 68000 computer build. One of his previous posts mentioned a working breadboard version but we figured it would be a ways off. Surprise, he’s got it working and what you see above took just 6 days of “occasional work” to get running.

The chip in use is actually a 68008 but we remember reading that he does plan to migrate to a 68000 because this one lacks the memory pins to address more than 1 MB of RAM. The trick here was just to get the thing running and he made some common choices to get there. For instance, he grounded the /DTACK in much the same way [Brian Benchoff] explained in his own 68k build.

We’re not sure if his address decoding was a time saver or not. If you study [Steve’s] original planning post you’ll learn that he’s going to use programmable logic to handle the address decoding. But above he wired up 74-series logic chips to perform these functions. On the one hand you know your Hardware Description Language isn’t the problem, but did you terminate one of those wires where you ought not?

Additional tripping points include a bouncing reset pin. Looking at that we’d tell [Steve] there’s a problem with his chip, except that this was his first thought as well. He went the extra mile by building and testing a replica of the reset system. This makes our brain spin… shouldn’t the reset be among the most reliable parts of a processor?

This isn’t one of those clean retrocomputers with every connection carefully planned out and wire wrapped. [Peter’s] created a true hack – a working 68k system on a breadboard created with whatever he had on hand at the time. The real gem of this system is the ROM. [Peter] replaced an EPROM chip with an Arduino.

In the not-so-good-old-days, microprocessors (and many microcontrollers) ran from an external ROM chip. This often was a UV-erasable EPROM. Carefully compiled code was burned into the EPROM with a device programmer. If the code wasn’t perfect, the EPROM had to be pulled and placed under a UV lamp for 20 minutes or so to erase it before it was time to try again. EPROM emulators were available, but they were way too expensive for the hobbyist.

Thankfully those days are far behind us now with the advent of EEPROM and then Flash. [Peter] didn’t want to revisit the past either, so he wrote a simple Arduino sketch which allowed it to act as an EPROM emulator, including address logging via the serial port.

The design still caused [Peter] some headaches, though. His major problem was a classic 68k issue, /DTACK timing. /DTACK or Data Transfer Acknowledge is one of several bus control signals used by the 68k. When the 68k performs a read from the data bus, it waits for /DTACK before it transfers data. The Arduino was too slow to release /DTACK in this case, which caused the 68k to think every read was immediately completed. There is a much clearer explanation of the 68k bus cycles on this Big Mess O Wires page. [Peter’s] solution was simple – a D flip-flop connected to the address strobe took care of the timing issues.

It took quite a bit of tinkering, but the system eventually worked. Peter was able to run the 68008 from its reset vector into a simple loop using the Arduino. It’s only fitting that the 68k program loaded by the Arduino was an LED blinker, everyone’s favorite hardware Hello World.

When you’re building one of the best homebrew computers ever created, you’ll also want a great case for it. This was [Simon]’s task when he went about building an enclosure for his Kiwi microcomputer.

We were introduced to the Kiwi last year as the end result of [Simon] designing the ultimate computer from the early to mid-1980s. Inside is a 68008 CPU, similar to the processor found in early Macs and Amigas, two SID chips taken from a Commodore 64, Ethernet, support for IDE hard drives and floppy disks, and a video display processor capable of delivering VGA resolution video at 32-bit color depth. Basically, if this computer existed in 1982, it would either be hideously expensive or extraordinarily popular. Probably both, now that I think about it.

The case for the Kiwi was carefully cut from ABS sheets, glued together with acetone, and painted with auto body paint by a friend. It’s a great piece of work, but the effort may be for naught; [Simon] is reworking the design of his Kiwi computer, and hopefully he’ll be spinning a few extra boards for everyone else that wants a piece of the Kiwi.

A few days ago when I posted a homebrew Motorola 68000 computer spectacular, I briefly mentioned a truly spectacular homebrew computer built by [Simon Ferber]. When I posted a link to a Youtube demo of his 68k board, he was working on a website to document the architecture design, hardware, and software. That website is now up (cache if you need it) and now we can all get a good look at the best homebrew computer ever built.

Built around the 68008 CPU – slightly less capable than the 68000 found in the original Macs, Amigas, and the TI-89 – [Simon]’s Kiwi computer has peripherals out the wazoo. A Yamaha V9990 Video Display Processor provides a 640×480 display with 32k colors. Two SID chips taken from a Commodore 64 provide stereo chiptune audio, and a floppy disk controller, IDE/ATA bus, and CS8900A Ethernet controller provide all the practical functionality you’d expect from an awesome computer.

On the software side of things, [Simon] is running Enhanced Basic 68k, but of course he can’t just use BASIC to fiddle around with all the cool chips on the Kiwi. With that in mind, he came up with a C-based toolchain that included porting libc to the Kiwi.

Like any good homebrew computer project, all the schematics, a bit of code, and a BOM are provided. [Simon] is currently working on (slightly) redesigning the PCB layout of the Kiwi, and we’ll be happy to see those files released. Anyone up for a Kiwi PCB group buy?

Introduced in 1979, the Motorola 68000 CPU was first used in very expensive and very high-end workstations from the likes of Sun and SGI. As the processor matured it became well-known for its use in the original Macintosh, early Amigas, and even the TI-89 graphing calculator and a few video game consoles such as the Sega Genesis and Atari Jaguar.

A few days ago when I posted a homebrew computer build based on the 65816 CPU, I lamented the lack of builds using the venerable Motorola 68k. Hackaday readers were quick to point out the many homebrew computers making use of this classic CPU, and I’m glad to post them here.

First up is an amazing 68008 build featuring an IDE disk interface, a floppy disk interface, 10base-T Ethernet connectivity, a real-time clock, and two SID synthesizer chips. As far as features go, this build takes the cake. Pity I can’t find a writeup.

Here’s a 68000-based computer built around the S-100 bus. Like the first computer to use the S-100 bus, the Altair 8800, this computer is plugged into a backplane that breaks out the data, address, and interrupt lines to every device on the bus.

Of course, no mention of backplane computers would be complete without a Eurocard version. [N8VEM] built a 68000 computer able to be plugged in to a backplane along with an IDE controller card and a display controller.

Finally, in true ‘giant mess of wires’ spirit, [Dajgoro] sent in his 68k single board computer featuring 512 kB of RAM and a 16k ROM. [Dajgoro] also took the time to wire in a PIC microcontroller, allowing him to expand his computer far beyond what vintage components would allow.

The 68k was – and still is – a very powerful CPU that far surpasses the capabilities of the 6502 and Z80 homebrew computers we see from time to time. Short of building a 486 or Pentium-based computer from scratch, building a 68k machine is one of the crowning achievements of hardware hackery, and something we hope to see more of in the future.