A Proof of Concept Flash Cart for the WonderSwan

Unless you’ve been to Japan or are fairly deep into the retro game collecting, you’ve probably never heard of the WonderSwan. It’s a handheld console, released after the Game Boy Color was beginning to show its age, and a bit before the introduction of the Game Boy Advance. It sold rather well in the only country it was released in, the game library is somewhat impressive, and there are quite a few homebrew games. Actually running these homebrew games is a challenge, though: each WonderSwan has a memory controller that maps the game ROM into the CPU’s memory. Without knowing how this controller chip works, the only way to run a homebrew cartridge is to turn on the machine with a real cart, go to the system menu, and swap the carts out. It turns out there’s a better solution, that includes programming CPLDs and looking at the output of a logic analyzer.

The first step towards [Godzil]’s efforts to create a Flash cart for the WonderSwan is to figure out the pinout of the cartridge connector – something that isn’t well documented for a system without a homebrew hardware scene. This was done in the usual way; with a lot of ribbon cable and patience This only provided an incomplete picture of how the WonderSwan interfaced with its carts, but after digging up an official development board, [Godzil] was able to make sense of all the signals.

After building a breakout board for the cartridge port, [Godzil] connected a DE0 Nano FPGA board and looked at all the signals. With just a little bit of VHDL, the memory controller could be reverse engineered and reimplemented. [Godzil] has his proof of concept working – video below – and the next part of his project will be to turn this into a proper Flash cart.

Continue reading “A Proof of Concept Flash Cart for the WonderSwan”

Building a Retro Computer that Never Existed

Sometimes you come across a build so far along you wish you could go back and enjoy it just a bit at a time. This C65 build is so far along, it’s like binge watching a retro computer build. One that never actually existed.

Okay, that’s admittedly a bit rash. But technically the C65 (successor to the Commodore C64) never saw its way through development. A good place to start looking in on the build is from the second post way back in March. The FPGA-based project is already looking promising with proof-of-concept display tests. Are we the only ones surprised by the 1920 native display resolution?

Checking back in June we see that there is some software working but a bounty of bugs will definitely keep [Paul] busy for a while. Fast forward to the beginning of September and he’s come full through to getting a network connection up and running.

The Wikipedia page on the C65 gives a good idea of how awesome this would have been back in the day had it actually made it to market. We suppose it joins the Commodore lists of would-haves and should-haves with the likes of the C128.

FPGA with Open Source Propeller 1 Running Spin

fpga-running-p8x32a-and-sidcog

Open Sourcing something doesn’t actually acquire meaning until someone actually uses what has been unleashed in the wild. We’re happy to see a working example of Propeller 1 on an FPGA dev board. That link takes you to a short description and some remapping of the pins to work with a BeMicro CV board. But you’ll want to watch the video below, or rather listen to it, for a bit more explanation of what [Sylwester] did to get this working.

You’ll remember that Parallax released the Propeller 1 as Verilog code a few weeks back. This project first loads the code onto the FPGA, then proves it works by running SIDcog, the Commodore 64 sound emulation program written in Spin for p8x32a processors.

We do find this to be an interesting first step. But we’re still waiting to see what type of hacks are made possible because of the newly available Verilog code. If you have a proof of concept working on other hardware, certainly tell us about it below. If you’ve been hacking on it and have something you want to show off, what are you waiting for?

Continue reading “FPGA with Open Source Propeller 1 Running Spin”

A MIPI DSI Display Shield/HDMI Adapter

MIPI DSI shield

[Tomasz] tipped us about the well documented MIPI DSI Display Shield / HDMI Adapter he put on hackaday.io. The Display Serial Interface (DSI) is a high speed packet-based interface for delivering video data to recent LCD/OLED displays. It uses several differential data lanes which frequencies may reach 1 GHz depending on the resolution and frame rate required.

The board explained in the above diagram therefore allows any HDMI content to be played on the DSI-enabled scrap displays you may have lying around. It includes a 32MB DDR memory which serves as a frame buffer, so your “slow” Arduino platform may have enough time to upload the picture you want to display.

The CP2103 does the USB to UART conversion, allowing your computer to configure the display adapter internal settings. The platform is based around the XC6SLX9 Spartan-6 FPGA and all the source code may be downloaded from the official GitHub repository, along with the schematics and gerbers. After the break we’ve embedded a demonstration video in which a Raspi drives an iPhone 4 LCD.

Continue reading “A MIPI DSI Display Shield/HDMI Adapter”

Open Source GPU Released

GPLGPU

Nearly a year ago, an extremely interesting project hit Kickstarter: an open source GPU, written for an FPGA. For reasons that are obvious in retrospect, the GPL-GPU Kickstarter was not funded, but that doesn’t mean these developers don’t believe in what they’re doing. The first version of this open source graphics processor has now been released, giving anyone with an interest a look at what a late-90s era GPU looks like on the inside, If you’re cool enough, there’s also enough supporting documentation to build your own.

A quick note for the PC Master Race: this thing might run Quake eventually. It’s not a powerhouse. That said, [Bunnie] had a hard time finding an open source GPU for the Novena laptop, and the drivers for the VideoCore IV in the Raspi have only recently been open sourced. A completely open GPU simply doesn’t exist, and short of a few very, very limited thesis projects there hasn’t been anything like this before.

Right now, the GPL-GPU has 3D graphics acceleration working with VGA on a PCI bus. The plan is to update this late-90s setup to interfaces that make a little more sense, and add DVI and HDMI output. Not bad for a failed Kickstarter, right?

An FPGA Based 6502 Computer

A diagram of the CHOCHI Board

It’s no secret that people love the 6502 processor. This historic processor powered some of our favorite devices, including the Apple II, the Commodore 64, and the NES. If you want to play with the 6502, but don’t want to bother with obtaining legacy chips, the CHOCHI board is for you.

While many people have built modern homebrew 6502 computers, the CHOCHI will be much easier for those looking to play with the architecture. It’s based on a Xilinx XC3S50 FPGA which comes preconfigured as a 6502 processor.

After powering on the board, you can load a variety of provided binaries onto it. This collection includes a BASIC interpreter and a Forth interpreter. Of course, you’re free to write your own applications in 6502 assembly, or compile C code for the device using the cc65 compiler.

If you get bored with the 6502 core, you can always grab Xilinx’s ISE WebPACK for free and use the board as a generic FPGA development tool. It comes with 128K of SRAM and 31 I/O pins. Not bad for a $30 board.

Sprite Graphics Accelerator on an FPGA

A demo running on a FPGA sprite accelerator

Graphics accelerators move operations to hardware, where they can be executed much faster. This is what allows your Raspberry Pi to display high definition video decently. [Andy]’s latest build is a 2D sprite engine, featuring hardware accelerated graphics on an FPGA.

In the simplest mode, the sprite engine just passes commands through to the LCD. This allows for basic control. The fun part sprite mode, which allows for sprites to be loaded onto the FPGA. At that point, you can show, hide, and move the sprite. By overlapping many sprites, you something like the demo shown above.

The FPGA is from Xilinx, and uses their Block RAM IP to store the state of the sprites. The actual sprite data is contained on a 128 Mb external flash chip, since they require significant space.

The game logic runs on a STM32 Cortex M4 microcontroller which communicates with the FPGA and orders the sprites around. The FPGA then deals with generating frames and sending them to the LCD screen, freeing up the microcontroller.

If you’re wondering about the LCD itself, it’s 3.2″, 640 x 360, and taken from a Ericsson U5 Vivaz cellphone. [Andy] has a detailed writeup on reverse engineering it. After the break, he gives us a video overview of the whole system.

Continue reading “Sprite Graphics Accelerator on an FPGA”