Reverse Engineering the Sony PocketStation

[Robson Couto] never actually owned a PlayStation in his youth, but that doesn’t mean he can’t have a later in life renaissance. In particular a Japan only accessory called the PocketStation caught his interest.

The item in question resided in the PlayStation’s memory card slot. It’s purpose was to add additional functionality to games and hopefully sell itself. Like the PokeWalker, Kinect, etc. It’s an age old tactic but the PocketStation had some interesting stuff going on (translated).

The biggest was its processor. Despite having a pathetic 32×32 mono screen, it hosted the same processor as the GameBoy Advance. Having acquired a card from an internet auction house [Robson] wanted to load up some of the ROMs for this device and see what it was like.

It took quite a bit of work. Luckily there is a ton of documentation floating around the internet thanks to the emulation scene and it wasn’t long before he convinced a microcontroller to pretend to be the memory card slot. Now anyone with some skill and a small piece of gaming history can play around with the rare ROM dump for the PocketStation.

The Dual-Core, ARM-Powered Commodore 64

There is no CPU that is better understood than the 6502 and its cousins the 6510, 6507, 6509, and whatever we’re calling the CPU in the NES. With this vast amount of documentation, just about anything can be done. Want a discrete and un-discreet 6502? Sure thing. It’s the NMOS version, though. Want an emulated version. Sure. With libraries porting the 6502 to every platform ever, there’s only one place left to go: putting a 6502 in a Commodore 64. Make it dual-core, too, so we can run CP/M.

This build is based on one of [telmomoya]’s earlier builds – a soft-core 6510 running on an ARM Cortex M3. The inspiration for this build came from a 6502 emulator running on an Arduino, which got [telmomoya] wondering what would happen if he attached some external RAM, CIA or a SID. Doing this on an Arduino is hard, but there are a few 5 Volt tolerant ARM chips out there, and with a few banks of SRAM, [tel] quickly had an emulated 6502 running EhBasic.

Running an emulated 6502 on an ARM chip is nothing new. What makes this build spectacular is the adaptation to the C64 motherboard. Since [telmomoya] was already breaking out the data and address lines to go to the SRAMs, it didn’t take much extra work to simply build an adapter for the DIP40 CPU socket on a C64. A few 74-series logic chips made the interface easy, and after a bit of soldering, [telmomoya] had a Commodore 64 powered by an ARM chip.

If you’re emulating one chip, you can emulate two, and with the Commodore 64, this leads to a few interesting possibilities. The C64 had a CP/M cartridge — a cartridge that contained a Z80 CPU, sharing the data and address bus with the 6510. This cartridge allowed the ‘toy computer’ C64 to run the ‘business’ CP/M operating system (and the Z80 made the Commodore 128 much cooler).  Since [telmomoya] was already emulating a CPU, emulating a second CPU wasn’t really that hard.

It’s a phenomenal build, and great if you’ve ever wanted to speed up VisiCalc.

Virtually Free Rapsberry Pis

One of the nice things about the Raspberry Pi is that it runs Linux and you can do a lot of development right on the board. The converse of that is you can do a lot of development on a Linux desktop and then move things over to the Pi once you get the biggest bugs out. However, sometimes you really need to run code on the actual platform.

There is, however, an in-between solution that has the added benefit of upping your skills: emulate a Pi on your desktop. If you use Linux or Windows on your desktop, you can use QEMU to execute Raspberry Pi software virtually. This might be useful if you don’t have a Pi (or, at least, don’t have it with you). Or you just want to leverage your large computer to simplify development. Of course we would be delighted to see you build the Pi equivalent of the Tamagotchi Singularity but that’s a bit beyond the scope of this article.

Since I use Linux, I’m going to focus on that. If you insist on using Windows, you can find a ready-to-go project on Sourceforge. For the most part, you should find the process similar. The method I’ll talk about works on Kubuntu, but should also work on most other Debian-based systems, including Ubuntu.

Continue reading “Virtually Free Rapsberry Pis”

GameGirl: A Better Portable Raspberry Pi

For better or worse, the most popular use for the Raspberry Pi – by far – is media centers and retro game consoles. No, the great unwashed masses aren’t developing Linux drivers for their Pi peripherals, and very few people are tackling bare metal ARM programming. That doesn’t mean creating a handheld console based on the Pi isn’t a worthy pursuit.

For their entry for the 2016 Hackaday Prize, [David] and [Jean-André] are building a portable Pi console that’s much better than an old Bondo-encrusted Game Boy enclosure stuffed with hot glue and wires. They’re doing this project the right way with a hardware accelerated display, custom software, and a high quality case.

[David] is in charge of the hardware, and that means making a very, very small handheld console. The design of this GameGirl is extremely similar to the old-school Game Boy Pocket (or Game Boy Light). There’s a D-pad, four buttons, select, start, and two ‘shoulder’ buttons on the back. The build is based on the Raspberry Pi Zero, and thanks to the Pi’s standard 40-pin header, [David] is able to configure the display to use an RGB565 DPI interface. This means the display is stupidly cheap while still leaving a few GPIO pins left over for the SPI, buttons, backlight, and PWM audio.

[Jean-André] is the other half of the team, and his contributions to open source software make him exceptionally qualified for this project. He’s the main developer for Lakka, a DIY retro emulation console, and the #5 RetroArch contributor. No, this project isn’t using RetroPie – and there’s a reason for that. Emulator hackers are spending a lot of time optimizing emulators for the Raspberry Pi, only because of RetroPi. If these emulator hackers spent their time optimizing for an API like LibRetro, you could eventually play a working version of Pilotwings 64 on the Raspberry Pi and every other platform LibRetro is available for. All the effort that goes into making a game work with a Raspberry Pi is effort that goes into making that game work for the PSP, Wii, iOS, and a PC. Yes, its philosophical pissing in the wind while saying, ‘this is what the community should do’; this is open source software, after all.

With the right ideas going into the hardware and software, [David] and [Jean-André] have an amazing project on their hands. It’s one of the most popular entries and are near the top of the charts in the community voting bootstrap effort where every like on a project gets the team a dollar for their project. GameGirl is shaping up to be a great project, and we can’t wait to see the it in action.

The HackadayPrize2016 is Sponsored by:

Coleco Chameleon is a Kickstarter Scam

Retro gaming consoles exploded with the introduction of the Raspberry Pi and other similar single-board Linux computers. They all work the same way in that they emulate the original game console hardware with software. The game ROM is then dumped to a file and will play like the original. While this works just fine for the vast majority of us who want to get a dose of nostalgia as we chase the magic 1-up mushroom, gaming purists are not satisfied. They can tell the subtle differences between emulation and real hardware. And this is where our story begins.

Meet the Coleco Chameleon. What appears to be just another run-of-the-mill retro gaming console is not what you think. It has an FPGA core that replicates the actual hardware, to the delight of hardcore retro game scam_04enthusiasts around the world. To get it to the masses, they started an ambitious 2 million US dollar Indiegogo campaign, which has unfortunately come to a screeching halt.

Take a close look at the header image. That blue circuit board in there is nothing but an old PCI TV tuning card. To make matters worse, it also appears that their prototype system which was displayed at the Toy Fair in New York was just the guts of an SNES Jr stuffed into their shell.

This scam is clearly busted. However, the idea of reconstructing old gaming console hardware in an FPGA is a viable proposition, and there is demand for such a device from gaming enthusiasts. We can only hope that the owners of the Coleco Chameleon Kickstarter campaign meant well and slipped up trying to meet demand. If they can make a real piece of hardware, it would be welcomed.

A Modern 386 Development Board

Some readers out there probably have nostalgic feelings for their first 386 based PC, the beeps and hisses of the modem, and the classic sound of a floppy drive’s stepper motor. Perhaps that turbo button that we could never quite figure out.

If you want the power of a 386 processor today, you’re in luck: [Pierre Surply] has developed a modern development board for the 80386SX CPU. This board is based on a 386 processor that comes in a LQFP package for “easy” soldering, and an Altera Cyclone IV FPGA.

To allow the CPU to run, the FPGA emulates the chipset you would usually find on a PC motherboard. The FPGA acts as both a bus controller and a memory controller for the CPU. On the board, there’s an SRAM chip and internal memory on the FPGA, which can be accessed through the 386’s bus access protocol.

The FPGA also provides debugging features. A supervisor application running on the FPGA gives debugging functionality via a FTDI USB to UART chip. This lets you control operation of the CPU from a PC for debugging purposes. The FPGA’s memory can be programmed through a JTAG interface.

The project is very well documented, and is a great read if you’re wondering how your old 386 actually worked. It can even be hand soldered, so the adventurous can grab the design files and give it a go. The francophones reading can also watch the talk in the video below.

Continue reading “A Modern 386 Development Board”

Commodore C16 Resurrection with a Raspberry Pi

[lactobacillusprime] had a non-working Commodore C16 and too many Raspberry Pi computers, so he decided to bring the C16 back to life by emulating it on the Pi. At the heart of the project is the Pi, along with a small board that converts the old style Commodore keyboards (and joysticks) to a USB port.

Once you have the keyboard as a USB port, the rest of the project is more or less mechanics and software. [lactobacillusprime] did a nice job of getting everything in the new case, along with all the I/O wires routed through the existing ports. For software, Emulation Station does the job of launching the Commodore emulation on the Pi.

Of course, there’s no reason to limit yourself to just the Commodore emulator. Emulation Station along with the right back end emulators will allow this machine to play games that no real Commodore C16 could.

Of course, we were happiest to see him boot up Commodore 64 BASIC. Perhaps we should complete all those half finished C64 BASIC projects we started back in the 1980’s. In general, we hate to see old computers gutted instead of repaired, but at least this one will continue running its software. If you are upset about seeing a machine gutted,  you can always switch over to our previous coverage of putting Commodore guts in a new box.

Continue reading “Commodore C16 Resurrection with a Raspberry Pi”