MC68k SBC with a monitor, keyboard and mouse

Motorola 68000 SBC Runs Again With A Raspberry Pi On Top

Single-board computers have been around a long time: today you might be using a Raspberry Pi, an Arduino, or an ESP32, but three decades ago you might find yourself programming a KIM-1, an Intel SDK-85, or a Motorola 68000 Educational Computer Board. These kind of boards were usually made by processor manufacturers to show off their latest chips and to train engineers who might use these chips in their designs.

[Adam Podstawczyński] found himself trying to operate one of these Motorola ECBs from 1981. This board contains a 68000 CPU (as used in several Macintoshes and Amigas), 32 kB of RAM, and a ROM program called TUTOR. Lacking any keyboard or monitor connections, the only way to communicate with this system is a pair of serial ports. [Adam] decided to make the board more accessible by adding a Raspberry Pi extended with an RS232 Hat. This add-on board comes with two serial ports supporting the +/- 12 V signal levels used in older equipment.

It took several hours of experimenting, debugging, and reading the extensive ECB documentation to set up a reliable connection; as it turns out, the serial ports can operate in different modes depending on the state of the handshake lines. When the Pi’s serial ports were finally set up in the right mode, the old computer started to respond to commands entered in the terminal window. The audio interface, meant for recording programs on tape, proved more difficult to operate reliably, possibly due to deteriorating capacitors. This was not a great issue, because the ECB’s second serial port could also be used to save and load programs directly into its memory.

With the serial connections working, [Adam] then turned to the aesthetics of his setup and decided to make a simple case out of laser-cut acrylic and metal spacers. Custom ribbon cables for the serial ports and an ATX break-out board for power connections completed the project, and the 40-year-old educational computer is now ready to educate its new owner on all the finer points of 68000 programming. In the video (embedded after the break) he shows the whole process of getting the ECB up and running.

[Adam] made a similarly clever setup with a Commodore 64 and an Arduino earlier. [Jeff Tranter] recreated a similar 68000 development board from scratch. And a few years ago we even featured our own custom-built 68k computer.

Continue reading “Motorola 68000 SBC Runs Again With A Raspberry Pi On Top”

The Amiga 2000 You Always Wanted

Back in the late 1980s, Commodore pulled the masterstroke of selling several models and generations of Amiga that were all powered by essentially the same speed 68000 and associated chipset. Sure, there were differences in the RAM and other options you could fit and later models had a few extra graphics modes. Still, the entry-level A500 did substantially the same as the high-end A2000. No matter, we the fans all wanted a 2000 anyway, though we typically found ourselves unable to afford one. It’s 2021 now though, so if you never achieved the dream of owning your own A2000, now you can build one of your own! It’s the task [Drygol] has taken on, with an A2000 made entirely from new components, save for a few salvaged Commodore-specific chips and connectors.

At its heart is a beautiful recreation of the original PCB that we’re guessing will be of great interest to owners whose NiCd batteries have leaked and corroded their originals. It’s all through-hole, but the sheer size of a motherboard still makes it a daunting prospect to solder by hand. There are a huge quantity of decoupling and ESD components that all have to be held with tape before the board is flipped over for soldering, and then all the chips are socketed. A Fat Agnes address generator was fitted on a RAM expansion daughterboard, leading to some significant problems as it proved not to be compatible and had to be removed.

The whole is put in a very low-profile PC case with appropriate risers for the Zorro slots, and then in goes a set of upgrades probably not seen in the same place since about 1993. We don’t recognize them all, but we can see accelerators, a floppy emulator, an HDD emulator using a CF card, and is that a network card we spy? This machine is still a work in progress, but we can guarantee it would have been an extreme object of desire thirty years ago. See it in action in the video below the break.

If rebuilding an Amiga interests you, we took a look at the state of the remanufactured parts scene for the platform last year.

Continue reading “The Amiga 2000 You Always Wanted”

Recreating The Mac SE Logic Board

When [Kai Robinson] found himself faced with the difficult task of saving as many Mac SE’s as he possibly could, the logical but daunting answer was to recreate the Mac SE logic board for machines that would otherwise be scrapped. These machines are over 30 years old and the PRAM battery often leaks, destroying parts and traces. Given that the logic board is a simple through-hole two four-layer board, how hard could it be?

The first step was to get some reference photos so [Kai] set to desoldering everything on the board. The list of components and the age of solder made this an arduous task. Then a composite image was produced by merging images together using a scanner and some Inkscape magic. in graphics software.

Rather than simply putting the pins in the right place and re-routing all the netlists, [Kai] elected instead to do a copy, trace for trace of the original SE board. [Kai] and several others on the forum have been testing the boards and tracking down the last few bugs and kinks in the design. An unconnected pin here and an improperly impedance matched resistor there. Hopefully, soon they’ll have Gerbers and design files ready for anyone should they need a new logic board PCB.

It’s no secret that we love the Macintosh SE here at Hackaday. We’ve seen new custom cases for it and now new PCBs for it. It does cause the mind to ponder though and wonder, what’s next?

Thanks [Toru173] for sending this one in!

Apple’s Best Computer Gets WiFi

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.

Ask Hackaday: Calling All 68k Experts

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?

Continue reading “Ask Hackaday: Calling All 68k Experts”

Breadboarding A 68000 Computer In Under A Week

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?

At any rate, great work so far. We can’t wait to see where this goes and we hope that it unfolds in a way that is as exciting as watching [Quinn Dunki’s] Veronica project take shape.

When Worlds Collide: 68008 Bootstrapped By An Arduino Uno


[Peter Bjornx] brings classic microprocessors and modern microcontrollers together with his Arduino bootstrapped 68008 computer. The Motorola 68008 is the 8-bit external bus version of the well-known 68000 (or 68k) microprocessor. A friend gave [Peter] one of these chips, so he built a simple computer around it.

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.

Thanks [Robert!]