My first design - Input please ...

[Tickled_Pink]

After much design and redesign I *think* I've finally come up with a schematic that'll work.

This is a simple EEPROM burner for the Atari XL/XE 8-bit computer. It connects to the joystick ports. The difficulty I had with this was due to the limited number of I/O pins available (8 - can't wait until a friend finally sends me the Atari 400 he promised me ... it'll make project work so much easier). I've noticed that a lot of simple EEPROM/EPROM programmer projects on the net are write only with no facility to read the memory back afterwards for verifying the data and so forth. That was something I wanted to incorporate.

Anyway, here's some technical info. Hopefully someone will be able to pick out some problems with the design.

The Atari 8-bit's joystick ports, from my recollection of past magazine articles, provides around 500mA. However, by the time it travels along the wire to the project board it seems to be a lot less. I blew up an LED when I connected it directly to the +5v and GND lines on one of the ports. But when I connect an LED to the port through the cable and the board, the light from the LED is much dimmer and I've yet to destroy one that way - even without a current limiting resistor.

The design of the project itself is based around the 4094 8-stage shift/store register with 3 stage outputs (I'll be specifically using the MC14094), the 4040 binary ripple counter, and the 74166 (I think I have the HC or HCT and not the LS, however) parallel in/serial out shift register.

The 4094 is used to output the data to be written to the EEPROM. The 4040 is used to select each memory address to read from/write to, and the 74166 is used to read the data back from the EEPROM.

The principles of operation are as follows:

Writing to the device
1. Clear U4 with the Master Reset input. This sets the counter to the first memory location.
2a. Enable U1. This also has the function of setting the EEPROM to 'Write Enable' mode.
2b. Send serial data to U1 from J1. This will write the data to the EEPROM.
2c. Disable U1 (just in case).
2d. Increment U4. Goto 2a and repeat process as often as necessary.

Reading from device
1. Disable U1 in case it hasn't already been done. This will also put the EEPROM into 'Output Enable' mode.
2. Clear U4.
3a. Load parallel data into U2 by setting 'PE' low.
3b. Load 8 bits of data into U2 and read the output from Q7. This is the data from the EEPROM.
3c. Increment U4. Goto 3a and repeat process as often as necessary.

Now, for the schematic ...

 

[Mosfet]

Why Pink what an ambitious design, here I was telling you how a 7404 works.

So, what happens is you're sending serial out, decoding it to parallel, programming a standard EEPROM like the 28C64, and reading it back by going from parallel to serial :?:

Fascinating :!:

I'm not familiar with Ataris. I built a EPROM programmer for an old Z80 micro years ago. It was memory mapped to shadow the operating system ROM. So it had to be switched into the RAM addresses to be read. I could program it in BASIC and loop enough to make wait states. My 8051 programmer has the split memory areas so it's kind of similar to that. Programming both kinds of PROMS was/is slow. But reading is just like RAM.

If I understand your design right, what kind of read speed do you expect?
Regards

 

[Tickled_Pink]

Ah ... well ... I have a confession to make.

Although this is my first attempt at designing something with electronics, I have a background in programming - including 6502 and 68000 assembly. So it's not difficult for me to work out how digital ICs work from looking at the datasheets (principles are basically the same). The hardest part I had when coming up with this one was figuring out the best parts to use.

I had originally intended to 'daisy chain' a number of 74259 chips but realised the design wouldn't work since I needed something that could be switched off to avoid bus contention. The original design used 6 ICs ... It's now down to 4. Just in the middle of wiring this sucker up.

This is only the first step towards a much larger project, but one which should be much easier to design using just 2 ICs to do pretty much the same thing ... but better 8)

Anyhow, you understood the design correctly. It's pretty straightforward but trying to access 20-plus pins from 8 is a nightmare to figure out, especially since you waste many of the 8 pins on IC control.

The read speeds, even in assembly language, are not going to be astronomical. I have read that the Atari's joystick ports are at least capable of around 900 baud when used for serial comms. The ultimate aim for this design is not as an EEPROM reader, however. The read facility has only been incorporated to allow verification of memory (e.g. to check if it's blank).

I realised a couple of weeks ago that the humble Atari 8-bit (and probably other 8-bit micros) could still be used as 'development workhorses' for designs that might eventually be attached to a microcontroller. Hence this project :wink:

And, of course, this board can also be manipulated from Basic.

 

[Mosfet]

What kind of storage did the Ataris have? Cassette, floppy or dare I say even a hard disk?
I liked going back to old micros and adding Dallas Semiconductor nonvolatile SRAMs.
I would do a little bank switching and move my data around.
[I was envious of those who could afford those new IBM XT's with their HUGE 40 meg hard drives] :lol:

 

[Tickled_Pink]

The Ataris used 5.25" floppies, although there were all kinds of third party add-ons. I was given a CSS Black Box by an avid Atari user. Unfortunately it doesn't work (he paid 300GBP for it second-hand and never got it to work) but it is the most powerful piece of kit available for the 8-bit. It provides the Atari with a SCSI hard drive interface, an RS-232 interface and parallel printer port. I've all got a floppy board add-on for it which, if it was working, would allow me to use standard PC 5.25" and 3.5" floppy drives.

You can also build something called an SIO2PC (or APE) cable, which is very popular. I haven't built one yet but intend to do so soon (have plenty 1489 chips). As I recall, it only uses one IC, a resistor and maybe a diode. It allows you to use an old PC as a slave device, through which you can use its parallel and serial ports, as well as its hard drive for the Atari.

You can also buy an IDE interface from a couple of places on the net - including from a guy in Germany (do a search for MyIDE).

Great minds think alike One of my ideas is also to connect a Dallas NVRAM to it. Have a couple here I want to play around with.