Bally/Stern MPU 27c256 single EPROM conversion.

13 August, 2010 (00:07) | Pinball | By: admin

Recently I have been experimenting with methods to replace the EPROMs on Bally/Stern MPUs with a single EPROM. This is the direction I’m planning to go with the more advanced version of my MPU daughter boards. Initially I was planning to use a 2764 EPROM to replace the original 2x 2732 EPROMs but the Motorola 6800 is capable of addressing a lot more memory than what is used on the original Bally and Stern MPUs. With that in mind I decided to increase the available address space for program ROM and RAM with my boards. I accomplished more ROM quickly using Oliver Kaegi’s great work. I am tempted to use this addressing scheme in the next version of my Bally/Stern MPU daughter boards because it’s so simple to implement with basic logic but ultimately I would like to use programmable logic for the address decoding so I can increase the available RAM dramatically. The NVRAM I’m using is 8kx8 so I can easily increase the available RAM by more than 16x and ROM by more than 8x using a 27c512 slapped across the whole address space. With that kind of silicon available even a hack like me can write some deep and cool game rules for these old games!

Below is a picture of the MPU I’m using to test these ideas. It’s starting to look pretty hacked. I like to think of it as SUPER CHARGED!

Click “Read more” for a more in depth review of Oliver’s ROM addressing method and how to use it with any game.

Oliver’s addressing method is quite brilliant. The hardware is extremely simple but it will take a bit of explaining to understand how it actually works. First let’s look at where the program ROM lives within the address space available to the CPU. Remember that the CPU has 16 address lines so that’s 2 to the 16th power addresses (65536). The program ROM on original boards lives in the bottom half of that address space in two 4K chunks (assuming the game uses 2732 EPROMs). What Oliver has done is take a 27c256 eprom and put it into the whole lower half of the available address space using only chunks of it for program code and leaving the rest unused. These unused addresses will never be read. This is somewhat wasteful because large chunks of the EPROM remain unused but it makes the address decoding much easier to deal with. The cost of EPROMs is really not an issue here anyway.

Instructions can be found here for Bally -35 and Stern MPU200.

In order to use this conversion with original game code you will need to create a custom ROM image with the original game code in the correct address space within the 27c256. I will explain how to create this ROM image below but first let’s look at the memory map for the program ROM on Bally/Stern MPUs. This explanation is based on 4K (2732) EPROM images.

The original program ROM address space is broken into 4 chunks. Each EPROM contains 2 of these chunks:

ROM image Memory Location (Hex) Memory Location (Decimal)
U2 First half: $1000-$17FF (Decimal: 4096-6143)
U2 Second half: $5000-$57FF (Decimal: 20480-22527)
U6 First half: $1800-$1FFF (Decimal: 6144-8191)
U6 Second half: $5800-$5FFF (Decimal: 22528-24575)

A 27c256 EPROM with A0-A14 connected to CPU A0-A14 will have ROM addressable from $0000-$7FFF (Decimal 0-32767). Looking at the table above we can see that our code will easily fit within this address space. It’s just a matter of putting the code in the right places. I won’t give a detailed explanation of the address decoding in this article. We will just assume that the EPROM is enabled when the appropriate addresses are read. When I first looked at this conversion I wondered why he was only using half of the available space on the EPROM. The answer is because it’s easier to just drop an EPROM across the whole address space. It makes the address decoding simpler. I intend to use this somewhat wasteful but elegant concept in future designs (27c512 across the WHOLE address space).

Another point to remember is that the Motorola 6800 CPU starts running it’s program at address $FFFF. This is the last address in the available space. There is no program code in this address space on the original MPU but the $F800-FFFF address space is “mirrored” to the end of the available address space (originally $5800-$5FFF). When using Oliver’s conversion the end of the address space is actually $7800-$7FFF so the last chunk of original game code needs to be copied here as well as to $5800-$5FFF.

Don’t worry if all of this hexadecimal is not making sense. Just follow these instructions to create a 27c256 ROM image that should let you use any original game code with Oliver’s 27c256 single EPROM conversion.

1. Download the game code. Most should be available from ipdb.org.
2. Download Oliver’s Vector home ROM files here. The archive will contain fsp.exe which we will use below to split the ROM images in half.
3. Download the 2048 byte file that we’ll use for padding in the EPROM here.
4. Open a command (DOS) prompt and navigate to the directory where you unzipped the Vector home ROM file downloaded above. You will also want to have your 2732 game code images in this directory. What we are going to do is split the ROM images in half creating 4 new files. Here is the command syntax:

fsp U2_2732_image.bin U2_split
fsp U6_2732_image.bin U6_split

Where U2_2732_image.bin and U6_2732_image.bin are the names of the U2 and U6 ROM images and U2_split and U6_split are the prefixes for the output files.

We should now have files named U2_split-0, U2_split-1, U6_split-0 and U6_split-1.

5. Now we can issue this command to create our image:

copy /b bdat-0 + bdat-0 + U2_split-0 + U6_split-0 + bdat-0 + bdat-0 + bdat-0 + bdat-0 + bdat-0 + bdat-0 + U2_split-1 + U6_split-1 + bdat-0 + bdat-0 + bdat-0 + U6_split-1 27c256_ROM_Image.bin

The command above must be entered as one string.

This will create a file called 27c256_ROM_Image.bin. Burn that to your EPROM and you’re ready to go!

Here are a couple more pictures of the MPU I’m currently hacking on.