classic hacks

2705 Articles

Hackaday Retro Edition: A New Commodore 64 Case

March 11, 2015 by 73 Comments

Some time in the 80s, the plastic injection molds for the Commodore 64C, the Commodore 128, and the Plus/4 were shipped from somewhere in Asia to the great Commodore Mother Brain in West Chester, Pennsylvania. These molds had already produced a million or two cases, but there were some issues with production – too much waste, or something like that. A mechanical engineer took a look at the molds, sent out some recommendations, and moved the 2500 pound molds to a corner of the building.

For some time after a gray day in April, 1994 these molds sat in a West Chester, Pennsylvania warehouse until they were sold off. They made their way to a plastics manufacturer around Dallas, Texas where they sat for twenty years. All things must pass, sometimes several times, and this plastics manufacturer closed down, contacted an auctioneer, and began to sell off some of their equipment.

The hero of our story, [Dallas Moore], owns a small business, buying and selling everything from Barbie dolls to antiques. He found an ad for an auction at a plastics manufacturing plant in the newspaper, and figuring he could find something interesting, headed out to the auction preview.

The auctioneer at this liquidation sale asked [Dallas] what he did, and mentioned there was something pretty cool tucked away in a warehouse full of hardened steel molds. Something about molds for old computers. These were the molds for the Commodore 64C, Commodore 128, and the Commodore Plus/4. A literal crucible of computing history, stacked on a pallet and up for sale.

The auctioneer said one of his friends was interested in the molds, and thought they would make a neat coffee table. Something about this struck [Dallas] the wrong way and for the entire drive home he thought about someone taking history and turning it in to a piece of furniture. He decided to buy these molds and lugged the three 2500 pound pieces of hardened steel to his shop. Not wanting to let a good piece of history go to waste, he contacted another plastics manufacturer, planned a run of a thousand or so Commodore 64C cases in red, white, and blue. [Dallas] is funding the whole production run through Kickstarter.

To me, this is one of the greatest retrocomputing successes in recent memory. There will always be someone putting SD cards in old computers, getting them on the Internet (and especially pointed towards our retro edition), and cloning complete systems in FPGAs. This, though, is a clear example of someone recognizing the historical importance of several thousand pounds of steel, realizing there’s a market out there, and doing the leg work to remanufacture these pieces of history.

I put in my $45 for a red one, and I tipped off [Bil Herd], designer of the C128 and Plus/4, to this Kickstarter. He’s been talking with [Dallas], there I’m sure he’ll chime in on the comments with some retellings of Commodore battle stories.

If it arrives in time, I’ll be bringing my limited-edition red 64C case to the Vintage Computer Festival in Wall, NJ April 17-19. That’s a plug for the event. If you’re in the area, you should come.

EDIT: [Dallas] has a different story of where the molds came from.

Revive The Demoscene With A LayerOne Demoscene Board

March 5, 2015 by 36 Comments

Demos, the demoscene, and all the other offshoots of computer arts had their beginning as intros for cracked Apple II, Speccy, and Commodore 64 games. Give it a few years, and these simple splash screens would evolve into a technological audio-visual experience. This is the birth of the demoscene, where groups of programmers would compete to create the best demonstration of computer graphics and audio.

For one reason or another, this demoscene was mostly confined to Europe; even today, 30 years after the Commodore 64, the North American demoscene is just a fraction of the size of the European scene. A very cool guy named [Arko] would like to change that, and to that end he built the LayerOne Demoscene Board.

If there is a problem with the modern demo scene, it’s that the hardware that’s usually used – C64s, Ataris, Spectrums, and Amigas – are old, somewhat rare, and dying. There’s also the fact that artists have been working on these old machines for decades now, and every single ounce of processing power and software trickery has been squeezed out of these CPUs. [Arko]’s board is a ground-up redesign of what a board that plays demos should be. There’s only one chip on the board – a PIC24F with three graphics acceleration units, color lookup tables, and the ability to output 16-bit VGA video up to 640×480 with 8-bit audio.

The first official competition with the LayerOne Demoscene Board will be at the 2015 LayerOne conference in Monrovia, CA on May 23. There are a few categories, including 4k and 64k JavaScript, Raspberry Pi, the LayerOne board, and a ‘Wild’ category. If you want to take a processor out of a toaster and make a demo, this is the category you’ll be entering. Of course Hackaday will be there, and we’ll be recording all the demos.

Below are a few examples of what the LayerOne Demoscene board can do, and you can also see a talk [Arko] gave at the Hackaday 10th anniversary party here. You can buy the Layerone Demoscene Board on the Hackaday Store

Continue reading “Revive The Demoscene With A LayerOne Demoscene Board” →

Origami Busts A Move With Dancing Paper

March 3, 2015 by 20 Comments

Origami cranes are cool, but do you know what’s cooler? Origami cranes dancing to the beat. That’s the challenge [Basami Sentaku] took on when he created Dancing Paper (YouTube link). You might remember [Basami] from his 8 bit harmonica hack. In Dancing Paper, paper cranes seem to dance all on their own – even performing some crazy spinning moves. Of course, the “magic” is due to some carefully written code, and magnets, lots of magnets.

Using magnets to move objects from below isn’t a new concept. Many of us have seen the “ice skating pond” Christmas decoration which uses the same effect. Unlike the skating pond,Dancing Paper has moving parts (other than the cranes themselves). Under the plastic surface are a series of individually controlled electromagnets. Each of the supporting dancers has a line of four magnets, while the featured dancer in the center has a 5×5 matrix. The 41 electromagnets were wound around bolts with the help of a Tamiya motor and gearbox.

The actual dance moves are controlled by C code which appears to be running on an Atmel microcontroller. Of course a microcontroller wouldn’t be able to drive those big coils, so some beefy TO-220 case transistors were employed to switch the loads. The cranes themselves needed a bit of modification as well. Thin pieces of wire travel from the neodymium magnets on their feet up to the body of the crane. The wire provides just enough support to keep the paper from collapsing, while still being flexible enough to boogie down.

Click past the break to see Dancing Paper in action!

Continue reading “Origami Busts A Move With Dancing Paper” →

BeagleSNES For Game Boy, Game Boy Advance, NES, And – Yes – SNES

March 3, 2015 by 18 Comments

By far the most common use for the Raspberry Pi is shoving a few dozen emulators on an SD card and calling it a day. Everybody’s got to start somewhere, right? There are other tiny, credit card-sized Linux boards out there, and [Andrew] is bringing the same functionality of the Raspi to the BeagleBone Black and BeagleBoard with BeagleSNES, an emulator for all the sane pre-N64 consoles.

BeagleSNES started as a class project in embedded system design, but the performance of simply porting SNES9X wasn’t very good by default. [Andrew] ended up hacking the bootloader and kernel, profiling the emulator, and slowly over the course of three years of development making this the best emulator possible.

After a few months of development, [Andrew] recently released a new version of BeagleSNES that includes OpenGL ES, native gamepad support through the BeagleBone’s PRU, and support for all the older Nintendo consoles and portables. Video demos below.

Continue reading “BeagleSNES For Game Boy, Game Boy Advance, NES, And – Yes – SNES” →

RetroPie Turned Game Gear

March 2, 2015 by 12 Comments

Running vintage console emulators on a Raspberry Pi seems to be the thing all the cool kids are doing. The coolest RetroPie builds take a vintage console – usually of the Nintendo genus – stuff a Raspi in there somehow, and Bob’s your uncle. [Phil Herlihy] over at Adafruit is throwing his hat into the ring with a similar build. For this one, though, he’s using Sega’s oft-maligned Game Gear. He might actually get more than a few hours out of the battery with this one, and the battery is rechargeable, too. You can’t beat that.

The build begins with tearing down an old Game Gear, chopping up the PCB to save the button contact, and starting to fit all the components in there. The display is completely replaced with a 3.5″ composite display, a bit larger than the 3.2″ display found in a stock Game Gear. That’s not a problem, there’s a surprising amount of space behind the bezel, and if you’re good enough with an xacto blade and a file, it will look stock.

The rest of the components include an amplifier board, battery charge regulator, a 2500mAh LiPo, and a Teensy to read the buttons. There are a few modifications required for the Pi, but the finished device presents a USB port to the outside world; keep a keyboard by your side, and this is a portable Pi in every respect.

Building An Industrial Control Unit With An Industrial Control Unit

February 26, 2015 by 28 Comments

Back in the 70s, industrial control was done with either relays and ladder logic or new programmable logic controllers. These devices turned switches on and off, moved stuff around a factory, and kept the entire operation running smoothly. In the late 70s, Motorola came out with an Industrial Control Unit stuffed into a tiny chip. The chip – the MC14500 – fascinated [Nicola]. He finally got around to building an ICU out of this chip, and although this was the standard way of doing things 30 years ago, it’s still an interesting build.

[Nicola]’s ICU is extremely simple, just eight relays, eight inputs, the MC14500, a clock, and some ROM. After wiring up the circuit, [Nicola] wrote a compiler, although this chip is so simple manually writing opcodes to a ROM wouldn’t be out of the question.

To demonstrate his ICU, [Nicola] connected up an on/off switch, a start button, and a stop button. The outputs are a yellow, green, and red lamp. It’s a simple task for even a relay-based control scheme, but [Nicola]’s board does everything without a hitch.

If you’re looking for something a little more complex, we saw the MC14500 being used as an almost-CPU last year.

Video below.

Continue reading “Building An Industrial Control Unit With An Industrial Control Unit” →

Diode Steering And Counting With A 555

February 25, 2015 by 27 Comments

While you’re not likely to see this technique used very much today, there’s a lot you can do with a 555, some logic chips, and a handful of diodes. [Fran] is here with a great example of using these simple parts to build a circuit that counts to zero, using parts you can probably find under your workbench.

[Fran] was inspired to build this diode counter from one of [Dave]’s Mailbags and [Colin Mitchell]’s 555 circuit book. The 555 is the standard component found in every parts drawer, but since we have tiny microcontrollers that cost the same as a 555, we’re not seeing the artistry of a simple timer chip and a few logic chips much these days.

This circuit began with a 555 attached to a 4017B decade counter. Simply by tying a few LEDs to the output of the 4017, [Fran] made a bunch of LEDs light up in sequence. Cool, but nothing unexpected. The real trick uses a few diodes and six LEDs to build a scanner – a line of LEDs that will blink from left to right, then right to left. Impressive, and with a little more circuitry it’s a Larson Scanner, as seen in Battlestar Galactica and Knight Rider.

The real trick for this technique comes when [Fran] pulls out a piece of protoboard, several dozen diodes, and seven old transistors to have a seven-segment display count from zero to nine. The 4017 simply counts out on ten pins, and each of these pins is wired to a bunch of diodes for each segment in the display. Add in a few resistors and a transistor, and [Fran] replicated what’s inside a seven-segment driver with discrete parts.

If counting to zero isn’t enough proof that you can do a whole lot with some diodes and logic chips, how about programming an Atari 2600 with one?

Video below.

Continue reading “Diode Steering And Counting With A 555” →