Universal classic console ROM emulator

IvyMike · Post by **IvyMike** » Mon Apr 30, 2007 3:03 pm

This would be a neat project. Is this practical and has anyone done this?

Universal classic console ROM emulator:

The small controller PCB would contain a microcontroller, on-board RAM to act as storage for the code to be executed as a ROM, and a powered USB port. Code to be executed would be stored on an external USB flash drive or USB SD card reader. The controller PCB would boot from the external USB flash device plugged into it and load whatever code was needed for the controller to emulate a ROM for the desired game console along with the code to be run from RAM as if it were in ROM. The controller board itself would plug into a gutted game cartridge in order to interface with the particular console's edge connector.

vb_master · Post by **vb_master** » Mon Apr 30, 2007 4:34 pm

That's called a "PC."

Post by **bicostp** » Mon Apr 30, 2007 4:37 pm

It's called a "computer".

Seriously, this sounds like quite the undertaking. Not only do you have to find a CPU powerful enough to handle all the systems you want to do (and necessary video and audio hardware), but you also have to do all the code: USB and SD decoding, code interpretation, and of course emulators.

The closest you can get without a hardware engineering degree is one of those ultralight handheld PCs loaded with emulators and a frontend like GameEx. Or load a bunch of emulators on a PSP. Either will work.

vskid · Post by **vskid** » Mon Apr 30, 2007 4:38 pm

vb_master wrote:That's called a "PC."

vb is back!!!
Why reinvent the wheel, just use a computer as stated.

IvyMike · Post by **IvyMike** » Mon Apr 30, 2007 5:12 pm

bicostp wrote:It's called a "computer".

Seriously, this sounds like quite the undertaking. Not only do you have to find a CPU powerful enough to handle all the systems you want to do (and necessary video and audio hardware), but you also have to do all the code: USB and SD decoding, code interpretation, and of course emulators.

The closest you can get without a hardware engineering degree is one of those ultralight handheld PCs loaded with emulators and a frontend like GameEx. Or load a bunch of emulators on a PSP. Either will work.

I think everyone is completely misunderstanding my question. The purpose of the interface would _not_ be to emulate the game console but, instead, to allow a standard flash memory device to act as a game ROM _for_ a classic console. These already exist commercially, but with only one exception that I know of they have to be purchased already built and require the use of the manufacturers' custom flash memory cartridges. Plus, they are _not_ universal adapters and are useful only with a given console (because, after all, they'd like to sell you a separate unit and custom flash cards for _each_ system you might own). I suspect the hacker community could come up with a DIY universal one.

The one home-built flash memory to game unit interface that I know of is one intended to act as an external floppy drive for the C64-on-a-chip in the C64 DTV handheld direct-to-tv game unit:

http://pontoppidan.info/lars/index.php?proj=mmc2iec

And here's the C64DTV (no longer in production):

http://www.c64dtv.co.uk/

Emulating a ROM with RAM and a microcontroller would, potentially, be simpler than emulating a hard drive as the MMC2IEC does.

If this cleared things up, please re-read my first post.

vskid · Post by **vskid** » Mon Apr 30, 2007 5:33 pm

Sounds like putting roms on a USB drive. Or like making a USB interface for the cartridges to plug into. I don't know, you seem to jump back and forth, could you possibly draw it? It might be a bit easier to understand if we had a picture to look at.

IvyMike · Post by **IvyMike** » Mon Apr 30, 2007 6:24 pm

vskid wrote:Sounds like putting roms on a USB drive.

Yes, that's basically what I'm talking about. Or on an SD flash card. Both are dirt cheap and their contents are easily modified by a PC. With a universal interface instead of the custom ones that are currently sold, you'd have a very cheap route to a multi-system software development interface that would be extremely flexible. All of the electronics would be in the flash memory interface card (aka ROM simulation card) which would just be plugged into modded game cartridges (with the flash interface module's connector wired to the cartridge's card edge connectors) for each game console.

Take a look at the interface described and pictured at the link below. It is the one I previously mentioned that allows an SD flash card to act as a C64 floppy for a C64 or the C64DTV game unit:

http://pontoppidan.info/lars/index.php? ... iec&page=2

That's all the hardware it took! The software/firmware required to to emulate a ROM using the same or similar microcontroller would probably be far simpler to write than the software/firmware needed for this device which has to simulate/emulate a C64 floppy drive.

IvyMike · Post by **IvyMike** » Mon Apr 30, 2007 7:16 pm

The concept:

vskid · Post by **vskid** » Mon Apr 30, 2007 10:10 pm

So which way are we going, load roms on SD card, plug into magic thing that makes it into a cartridge and into the system and run it on the system?

IvyMike · Post by **IvyMike** » Tue May 01, 2007 10:20 am

vskid wrote:So which way are we going, load roms on SD card, plug into magic thing that makes it into a cartridge and into the system and run it on the system?

Yes, not just game ROMs, but any code executable on the particular game console. And the "magic" accomplished by the flash-to-ROM emulation hardware is far less "magic" than the tiny interface that I linked to above that makes an SD card act like a C64 floppy drive.

I think this would make a fantastic open-source, cooperative project.

jeroen · Post by **jeroen** » Tue May 01, 2007 10:26 am

Stil depending on system. You'd need to make a.) a cart with only one mapper supported. (easiest) b.) hard method use an fpga to emulate mapper chips.

edit: and it could only do one system. Period.

IvyMike · Post by **IvyMike** » Tue May 01, 2007 11:55 am

jeroen wrote:Stil depending on system. You'd need to make a.) a cart with only one mapper supported. (easiest) b.) hard method use an fpga to emulate mapper chips.

edit: and it could only do one system. Period.

I don't understand how a microcontroller couldn't be programmed to do the mapping in code loaded at boot for a particular console ROM type considering that modern microcontrollers can operate at clock speeds many multiples of old gaming consoles. And I can't see how emulating a ROM with RAM would be so difficult. The code would be moved into on-board RAM on the interface board from the flash memory. Interfacing with the ROM cartridge card edge would be done with a number of tri-state latches sufficient to cover the maximum number of I/O lines for every console cartridge that one desires to emulate.

Post by **gannon** » Tue May 01, 2007 12:09 pm

ASFAIK, the NES would be the hardest system to do something like this on because of the amount of mappers. It *is* possible though to have different cartridge PCBs for each system, with another board containing a reprogramable FPGA to do mapping/logic/etc and a storage device (CF, SD, IDE, etc). It'd be difficult to do though, and the best start would be to look at existing carts of that nature and pick one to modify.

IvyMike · Post by **IvyMike** » Tue May 01, 2007 12:24 pm

gannon wrote:ASFAIK, the NES would be the hardest system to do something like this on because of the amount of mappers. It *is* possible though to have different cartridge PCBs for each system, with another board containing a reprogramable FPGA to do mapping/logic/etc and a storage device (CF, SD, IDE, etc). It'd be difficult to do though, and the best start would be to look at existing carts of that nature and pick one to modify.

I've found a whole bunch of Genesis tech data and will start there. Thanks.