intellivision: eprom + burning

[maximebeauvais]

hey,

 

at one point I have programmed an atari 2600 games (hello world + a rolling screen with my name!!!). I was going to burn it with a eprom programmer but I found someone to do it for me.

 

now I will like to take some of the intellivision rom that exist on the internet and put it in an intellivision cart.

 

1) is there any board available somewhere

2) eprom?

3) programmer?

 

any help with this will be nice. thanks

[maximebeauvais]

is there someone that could help me?

 

thanks

[HammR25]

It would probably just be easier to get this.

[Wickeycolumbus]

If you still want to go the eprom way, I would go with this programmer. It has been very good to me. Not sure what kind of chip you need, but this programmer most likely supports it.

 

http://www.progshop.com/shop/programmer/BX...programmer.html

[intvnut]

If you still want to go the eprom way, I would go with this programmer. It has been very good to me. Not sure what kind of chip you need, but this programmer most likely supports it.

 

http://www.progshop.com/shop/programmer/BX...programmer.html

 

The Intellivision has a time-multiplexed 16-bit bus. You'll need either 2 8-bit or 1 16-bit EPROM, since the CP-1600 opcodes and all the original games are 10 bits wide. (The existing homebrews use a single 27C1024. Most homebrews also use the full 16-bit bus width.) You also need some logic to decode the bus controls and to latch and decode the address. You can do this with discrete TTL (like the old T-Cards did), or the modern way in a CPLD.

 

Note that unlike the Atari, you can't easily take an existing game, desolder the ROM and solder in an EPROM in its place. (Well, the Atari also needs an inverter for the chip-select, but that's fairly minor.) The Intellivision used custom GI ROMs that did their own bus decoding and address latching/decoding. There were no EPROM versions of these. You have to build it yourself.

 

Nobody that I know sells blank, ready to go boards. All the homebrews I know about use the same design, and have been fabbed as demand requires.

[intvnut]

BTW, although I wouldn't actually build such a board myself, since I'd rather do stuff with microcontrollers to emulate ROMs, it wouldn't be hard to breadboard up an EPROM-based board that emulates a cartridge similarly to how a T-Card does it, using a bunch of 2732 EPROMs to do it. Note that you'll want an external 5v supply if you go above about 16K x 16 (8 EPROMs), since this old tech draws a fair bit of current and the Intellivision's power supply apparently isn't up to it. (I've seen some of Mattel's protos for their larger games and they have a supplemental power connector.)

 

High level parts list:

 

• 2 8-bit latches (74LS373 seems appropriate here)
  
• 2 2732 EPROMs for every 4K words of game image
  
• 4 to 16 decoder with active-low outputs (74LS154 seems appropriate here)
  
• 3 to 8 decoder with active low outputs (74LS138 seems appropriate here)
  
• A 74LS00 quad 2-input NAND gate
  

 

The basic idea is as follows: Split the EPROMs into two data buses, one for DB0 through DB7 and one for DB8 through DB15. For the low bus, connect all the D0s for all the EPROMs together and connect that to the Intellivision's DB0. Likewise for D1 going to DB1, etc. up through DB7. For the high bus, connect all the D0s together and connect that to the Intellivision's DB8. Likewise for D1 going to DB9 up through D7 going to DB15.

 

Now connect all the EPROMs' A0 thru A11 together into a bus, and route that to the outputs of the latches. Connect A0 - A7 to the output of one latch, and A8 through A11 to the lower four bits of the other latch. Connect the Intellivision's DB0 - DB7 to the inputs of the latch you connected A0 - A7 to. Connect the Intellivision's DB8 - DB15 to the input of the latch you connected A8 through A11 to.

 

Now you're most of the way there: You can drive out a 16 bit piece of data on the bus, and you can provide 12 bits of address to each of the EPROMs. Now you just need the control and decode logic.

 

For address decode, connect the 4-to-16 decoder's inputs to the upper four outputs of the second latch. This will decode your ROMs into 4K pages of memory. Next, wire outputs that correspond to your memory map to the ~CS inputs on pairs of EPROMs that will serve up that address range. For example, suppose you are setting things up for a 16K game with ROM at $5xxx, $6xxx, $Dxxx and $Fxxx. Connect the "5" output to the ~CS inputs of one pair, the "6" output to the ~CS inputs of another pair, and so on. By "pair", I mean one EPROM on the "low" bus, and one EPROM on the "high" bus.

 

For bus decode, you need to generate two things: A latch enable that tells the latches when to capture an address, and an output enable that tells the selected EPROM to assert its data on the bus. The 74LS138 computes most of this. The rest will need some NAND gates.

 

Connect BDIR, BC2 and BC1 to the C, B and A inputs of the 3-to-8 decoder. Now the 8 outputs of the 3-to-8 decoder correspond to this truth table:

 

BUS PHASES

 

BDIR BC2 BC1 . .NAME . .DESCRIPTION

---- --- --- . .---- . .--------------------------------------------

. 0 . 0 . 0 . . NACT . .No ACTion

. 0 . 0 . 1 . . ADAR . .Addressed Data to Address Register (DTB+BAR)

. 0 . 1 . 0 . . IAB . . Interrupt Address to Bus (ignored)

. 0 . 1 . 1 . . DTB . . Data To Bus

. 1 . 0 . 0 . . BAR . . Bus to Address Register

. 1 . 0 . 1 . . DW . . .Data Write (ignored)

. 1 . 1 . 0 . . DWS . . Data Write Strobe (ignored)

. 1 . 1 . 1 . . INTAK . INTerrupt AcKnowledge . .(Alias for BAR, ignored)

 

You can ignore INTAK: The console never generates it externally. And since this is EPROM only, we can ignore DW and DWS. We can also ignore IAB since that's handled by the Intellivision's EXEC.

 

Connect output #1 (ADAR) and #3 (DTB) to the inputs of one NAND gate. Route this output to both inputs of another NAND. This will give you your ~OE signal to route to all the EPROMs. Truth table:

 

~ADAR .~DTB .OE . ~OE

----- .---- .--- .---

. 0 . . .0 . .1 . .0 . (can't happen)

. 0 . . .1 . .1 . .0

. 1 . . .0 . .1 . .0

. 1 . . .1 . .0 . .1

 

Connect output #1 (ADAR) and #4 (BAR) to the inputs of another NAND gate. This will give your "G" input to the octal latches (74LS373). Truth table:

 

~ADAR .~BAR . G

----- .---- .---

. 0 . . .0 . .1

. 0 . . .1 . .1

. 1 . . .0 . .1

. 1 . . .1 . .0

 

And then hook up all your power, ground, etc. On the 74LS138 and 74LS154, make sure to hook up your enables, too. And for good measure, you might want to sprinkle some .1uF capacitors around between power and ground to keep your power supplies clean. Put one near each of the pairs of EPROMs, since they'll be switching onto the buses and will have nice current spikes to go with it.

 

To connect to the actual Intellivision, one way to do it would be to take an existing board, desolder the ROM, and solder in wires to bring to your breadboard. Or, if you prefer, get some ribbon cable and some IDC connectors, which is what I did. In my case, rather than desolder, I popped the SBP-640 out of a spare Intellivoice. I can give you its pinout if you need it.

 

I *think* that should give you a working EPROM board. You'll need a few breadboards and plenty of wires. :-) I just came up with this circuit off the top of my head, based on what I remember of these components. There may be a couple minor gotchas in there, but they shouldn't be too major. Mea culpa.

 

If somebody decides to build one of these, I can tell you how to split a ROM image up so that you can program it properly across all these EPROMs.

Edited July 25, 2008 by intvnut