Data 6000 Repair and Toubleshooting

[Rerouter]

Over the past few months i have picked back up my spectrum analyser project  and now i have reached a point where i feel goes a tad over my current level of understanding,

History:
This item came to me pretty much as a bag of modules, someone had stripped this thing back to bare bones likely in a previous attempt to repair it and must have given up, leaving me with pots of screws and parts, and searching for a very hard to find manual 

A few months later i purchased the manual from manuals-plus and started making some headway, however was still left with no schematics of either power supply sections, or how the CRT was meant to be hooked up 

After a week of trying every combination i found what i though was right, powered it on and got only the analog plugin showing signs of life, no CRT no keyboard lights etc,

I successfully reverse engineered the Rear power supply and found 3 dead electrolytic and 1 shorted tantalum, which meant the supply was only giving out a very wobbly 5V rail and the +-15V rails where sitting grounded, following repairing and tweaking the correct voltage output i tried my luck again, to receive the same result, which i later found out is due to the rest of the device using an internal switch mode supply for its +5V rail,

I then proceeded to again reverse engineer the internal power supply, replaced close to 8 tantalum's, and 1 electro, and 4 power resistors (tantalum across current limiting resistor disabling it  ) and successfully got all the output voltages reading correctly, then tweaked to read dead on 5V,

Upon testing back in the system, a good 3-4 tantalum's popped on the CRT coil driver at the sudden restoration of a supply rail, and equally had to be replaced, tried one more time and finally had the power section in working order,

At this point i was made better aware that the CRT driver board and a diagnostic plug underneath the CRT shared the exact same shape plug, and that i had plugged the coils directly between some supply rails, leaving me uncertain of its condition  , (may need to replace but seems fairly common NEC model) Luckily it had an external output for X, Y and Z on the display drive board, but with nothing coming out of either of the 3, left me with either the CPU or RAM/ROM Board at fault.

Current Situation:
Following a basic troubleshooting flowchart in the manual I confirmed the fault lies within either the CPU board or RAM/ROM (Memory) Board, as the CPU is resetting every 64ms from a timeout, (hardware on CPU page 3 of 5) and would like some help narrowing down possible culprits

First Though, Each page contains signatures, relating to the state of the machine between a start and stop pulse (CPU Page 4, both signals happen at 6.1Hz) and i would greatly appreciate it if anyone had any clue on how to decode what they refer to, with the more interesting point to me being so far that when inverted the last 2 characters remain the same... which would allow me to test the entire CPU board, but sadly not the Memory as that requires the use of a diagnostics board that was a sold separately add-on at the time..

Next Up, On Memory Page 1, There is a PROM that decodes the chip enable pins of all the EPROMs housing the operating system, and however i approach it, it seems to me that it may be corrupted,

Code: [Select]

000000000 -> 1001
000000001 -> 1001
000000010 -> 1001
000000011 -> 1001
000000100 -> 1001
000000101 -> 1001
000000110 -> 1001
000000111 -> 1001
000001000 -> 0000
000001001 -> 0000
000001010 -> 0000
000001011 -> 0000
000001100 -> 1001
000001101 -> 1001
000001110 -> 1001
000001111 -> 1001
000010000 -> 0000
000010001 -> 0000
000010010 -> 0000
000010011 -> 0000
000010100 -> 1001
000010101 -> 1001
000010110 -> 1001
000010111 -> 1001
000011000 -> 0000
000011001 -> 0000
000011010 -> 0000
000011011 -> 0000
000011100 -> 1001
000011101 -> 1001
000011110 -> 1001
000011111 -> 1001
000100000 -> 0000
000100001 -> 0000
000100010 -> 0000
000100011 -> 0000
000100100 -> 1001
000100101 -> 1001
000100110 -> 1001
000100111 -> 1001
000101000 -> 0000
000101001 -> 0000
000101010 -> 0000
000101011 -> 0000
000101100 -> 1001
000101101 -> 1001
000101110 -> 1001
000101111 -> 1001
000110000 -> 0000
000110001 -> 0000
000110010 -> 0000
000110011 -> 0000
000110100 -> 1001
000110101 -> 1001
000110110 -> 1001
000110111 -> 1001
000111000 -> 0000
000111001 -> 0000
000111010 -> 0000
000111011 -> 0000
000111100 -> 1001
000111101 -> 1001
000111110 -> 1001
000111111 -> 1001
001000000 -> 0000
001000001 -> 0000
001000010 -> 0000
001000011 -> 0000
001000100 -> 1001
001000101 -> 1001
001000110 -> 1001
001000111 -> 1001
001001000 -> 0000
001001001 -> 0000
001001010 -> 0000
001001011 -> 0000
001001100 -> 1001
001001101 -> 1001
001001110 -> 1001
001001111 -> 1001
001010000 -> 0000
001010001 -> 0000
001010010 -> 0000
001010011 -> 0000
001010100 -> 1001
001010101 -> 1001
001010110 -> 1001
001010111 -> 1001
001011000 -> 0000
001011001 -> 0000
001011010 -> 0000
001011011 -> 0000
001011100 -> 1001
001011101 -> 1001
001011110 -> 1001
001011111 -> 1001
001100000 -> 0000
001100001 -> 0000
001100010 -> 0000
001100011 -> 0000
001100100 -> 1001
001100101 -> 1001
001100110 -> 1001
001100111 -> 1001
001101000 -> 0000
001101001 -> 0000
001101010 -> 0000
001101011 -> 0000
001101100 -> 1001
001101101 -> 1001
001101110 -> 1001
001101111 -> 1001
001110000 -> 0000
001110001 -> 0000
001110010 -> 0000
001110011 -> 0000
001110100 -> 1001
001110101 -> 1001
001110110 -> 1001
001110111 -> 1001
001111000 -> 0000
001111001 -> 0000
001111010 -> 0000
001111011 -> 0000
001111100 -> 1001
001111101 -> 1001
001111110 -> 1001
001111111 -> 1001
010000000 -> 0001
010000001 -> 0001
010000010 -> 0001
010000011 -> 0001
010000100 -> 1010
010000101 -> 1111
010000110 -> 1111
010000111 -> 1111
010001000 -> 1111
010001001 -> 1111
010001010 -> 1111
010001011 -> 1111
010001100 -> 1111
010001101 -> 1111
010001110 -> 1111
010001111 -> 1111
010010000 -> 1111
010010001 -> 1111
010010010 -> 1111
010010011 -> 1111
010010100 -> 1111
010010101 -> 1111
010010110 -> 1111
010010111 -> 1111
010011000 -> 1111
010011001 -> 1111
010011010 -> 1111
010011011 -> 1111
010011100 -> 1111
010011101 -> 1111
010011110 -> 1111
010011111 -> 1111
010100000 -> 1111
010100001 -> 1111
010100010 -> 1111
010100011 -> 1111
010100100 -> 1111
010100101 -> 1111
010100110 -> 1111
010100111 -> 1111
010101000 -> 1111
010101001 -> 1111
010101010 -> 1111
010101011 -> 1111
010101100 -> 1111
010101101 -> 1111
010101110 -> 1111
010101111 -> 1111
010110000 -> 1111
010110001 -> 1111
010110010 -> 1111
010110011 -> 1111
010110100 -> 1111
010110101 -> 1111
010110110 -> 1111
010110111 -> 1111
010111000 -> 1111
010111001 -> 1111
010111010 -> 1111
010111011 -> 1111
010111100 -> 1111
010111101 -> 1111
010111110 -> 1111
010111111 -> 1111
011000000 -> 1111
011000001 -> 1111
011000010 -> 1111
011000011 -> 1111
011000100 -> 1111
011000101 -> 1111
011000110 -> 1111
011000111 -> 1111
011001000 -> 1111
011001001 -> 1111
011001010 -> 1111
011001011 -> 1111
011001100 -> 1111
011001101 -> 1111
011001110 -> 1111
011001111 -> 1111
011010000 -> 1111
011010001 -> 1111
011010010 -> 1111
011010011 -> 1111
011010100 -> 1111
011010101 -> 1111
011010110 -> 1111
011010111 -> 1111
011011000 -> 1111
011011001 -> 1111
011011010 -> 1111
011011011 -> 1111
011011100 -> 1111
011011101 -> 1111
011011110 -> 1111
011011111 -> 1111
011100000 -> 1111
011100001 -> 1111
011100010 -> 1111
011100011 -> 1111
011100100 -> 1111
011100101 -> 1111
011100110 -> 1111
011100111 -> 1111
011101000 -> 1111
011101001 -> 1111
011101010 -> 1111
011101011 -> 1111
011101100 -> 1111
011101101 -> 1111
011101110 -> 1111
011101111 -> 1111
011110000 -> 1111
011110001 -> 1111
011110010 -> 1111
011110011 -> 1111
011110100 -> 1111
011110101 -> 1111
011110110 -> 1111
011110111 -> 1111
011111000 -> 1111
011111001 -> 1111
011111010 -> 1111
011111011 -> 1111
011111100 -> 1111
011111101 -> 1111
011111110 -> 1111
011111111 -> 1111
100000000 -> 1111
100000001 -> 1111
100000010 -> 1111
100000011 -> 1111
100000100 -> 1111
100000101 -> 1111
100000110 -> 1111
100000111 -> 1111
100001000 -> 1111
100001001 -> 1111
100001010 -> 1111
100001011 -> 1111
100001100 -> 1111
100001101 -> 1111
100001110 -> 1111
100001111 -> 1111
100010000 -> 1111
100010001 -> 1111
100010010 -> 1111
100010011 -> 1111
100010100 -> 1111
100010101 -> 1111
100010110 -> 1111
100010111 -> 1111
100011000 -> 1111
100011001 -> 1111
100011010 -> 1111
100011011 -> 1111
100011100 -> 1111
100011101 -> 1111
100011110 -> 1111
100011111 -> 1111
100100000 -> 1111
100100001 -> 1111
100100010 -> 1111
100100011 -> 1111
100100100 -> 1111
100100101 -> 1111
100100110 -> 1111
100100111 -> 1111
100101000 -> 1111
100101001 -> 1111
100101010 -> 1111
100101011 -> 1111
100101100 -> 1111
100101101 -> 1111
100101110 -> 1111
100101111 -> 1111
100110000 -> 1111
100110001 -> 1111
100110010 -> 1111
100110011 -> 1111
100110100 -> 1111
100110101 -> 1111
100110110 -> 1111
100110111 -> 1111
100111000 -> 1111
100111001 -> 1111
100111010 -> 1111
100111011 -> 1111
100111100 -> 1111
100111101 -> 1111
100111110 -> 1111
100111111 -> 1111
101000000 -> 1111
101000001 -> 1111
101000010 -> 1111
101000011 -> 1111
101000100 -> 1111
101000101 -> 1111
101000110 -> 1111
101000111 -> 1111
101001000 -> 1111
101001001 -> 1111
101001010 -> 1111
101001011 -> 1111
101001100 -> 1111
101001101 -> 1111
101001110 -> 1111
101001111 -> 1111
101010000 -> 1111
101010001 -> 1111
101010010 -> 1111
101010011 -> 1111
101010100 -> 1111
101010101 -> 1111
101010110 -> 1111
101010111 -> 1111
101011000 -> 1111
101011001 -> 1111
101011010 -> 1111
101011011 -> 1111
101011100 -> 1111
101011101 -> 1111
101011110 -> 1111
101011111 -> 1111
101100000 -> 1111
101100001 -> 1111
101100010 -> 1111
101100011 -> 1111
101100100 -> 1111
101100101 -> 1111
101100110 -> 1111
101100111 -> 1111
101101000 -> 1111
101101001 -> 1111
101101010 -> 1111
101101011 -> 1111
101101100 -> 1111
101101101 -> 1111
101101110 -> 1111
101101111 -> 1111
101110000 -> 1111
101110001 -> 1111
101110010 -> 1111
101110011 -> 1111
101110100 -> 1111
101110101 -> 1111
101110110 -> 1111
101110111 -> 1111
101111000 -> 1111
101111001 -> 1111
101111010 -> 1111
101111011 -> 1111
101111100 -> 1111
101111101 -> 1111
101111110 -> 1111
101111111 -> 1111
110000000 -> 1111
110000001 -> 1111
110000010 -> 1111
110000011 -> 1111
110000100 -> 1111
110000101 -> 1111
110000110 -> 1111
110000111 -> 1111
110001000 -> 1111
110001001 -> 1111
110001010 -> 1111
110001011 -> 1111
110001100 -> 1111
110001101 -> 1111
110001110 -> 1111
110001111 -> 1111
110010000 -> 1111
110010001 -> 1111
110010010 -> 1111
110010011 -> 1111
110010100 -> 1111
110010101 -> 1111
110010110 -> 1111
110010111 -> 1111
110011000 -> 1111
110011001 -> 1111
110011010 -> 1111
110011011 -> 1111
110011100 -> 1111
110011101 -> 1111
110011110 -> 1111
110011111 -> 1111
110100000 -> 1111
110100001 -> 1111
110100010 -> 1111
110100011 -> 1111
110100100 -> 1111
110100101 -> 1111
110100110 -> 1111
110100111 -> 1111
110101000 -> 1111
110101001 -> 1111
110101010 -> 1111
110101011 -> 1111
110101100 -> 1111
110101101 -> 1111
110101110 -> 1111
110101111 -> 1111
110110000 -> 1111
110110001 -> 1111
110110010 -> 1111
110110011 -> 1111
110110100 -> 1111
110110101 -> 1111
110110110 -> 1111
110110111 -> 1111
110111000 -> 1111
110111001 -> 1111
110111010 -> 1111
110111011 -> 1111
110111100 -> 1111
110111101 -> 1111
110111110 -> 1111
110111111 -> 1111
111000000 -> 1111
111000001 -> 1111
111000010 -> 1111
111000011 -> 1111
111000100 -> 1111
111000101 -> 1111
111000110 -> 1111
111000111 -> 1111
111001000 -> 1111
111001001 -> 1111
111001010 -> 1111
111001011 -> 1111
111001100 -> 1111
111001101 -> 1111
111001110 -> 1111
111001111 -> 1111
111010000 -> 1111
111010001 -> 1111
111010010 -> 1111
111010011 -> 1111
111010100 -> 1111
111010101 -> 1111
111010110 -> 1111
111010111 -> 1111
111011000 -> 1111
111011001 -> 1111
111011010 -> 1111
111011011 -> 1111
111011100 -> 1111
111011101 -> 1111
111011110 -> 1111
111011111 -> 1111
111100000 -> 1111
111100001 -> 1111
111100010 -> 1111
111100011 -> 1111
111100100 -> 1111
111100101 -> 1111
111100110 -> 1111
111100111 -> 1111
111101000 -> 1111
111101001 -> 1111
111101010 -> 1111
111101011 -> 1111
111101100 -> 1111
111101101 -> 1111
111101110 -> 1111
111101111 -> 1111
111110000 -> 1111
111110001 -> 1111
111110010 -> 1111
111110011 -> 1111
111110100 -> 1111
111110101 -> 1111
111110110 -> 1111
111110111 -> 1111
111111000 -> 1111
111111001 -> 1111
111111010 -> 1111
111111011 -> 1111
111111100 -> 1111
111111101 -> 1111
111111110 -> 1111
111111111 -> 1111

The Truth Table i Nutted out is: (D0,D1,D2,D3)
XXX1 = Select ROM
xxx0 = select RAM

000X = BERR Low
100X = Staten 01 Low
010X = Staten 02 Low
110X = Staten 03 Low
001X = Staten 04 Low

however looking through the contents of that prom, i can only find a way to trigger a BERR (Bus Error) or enable the first EPROM pair, and there is definitely a decent whack of control software on the other 3, like for the first 128 addressed something overwrote the center 2 bits with 0's.... , In which case would there be any way i could get some help in determining which addresses referred to those other roms even if just nudging me on the right direction on disassembling the roms, so that i could possible reconstruct it,

And Third And Final thought, possibly a RAM Chip has died, if such was the case, would there be anything special to testing it? Or would it just be a case of writing all 1's Read it back and then all 0's? and flagging if any bit did not read out correctly?,

Thanks Immensely In Advance, this thing is more of a pet project than a necessity, but i really want to get this thing going, 
In the interest of getting some help, i have scanned and cleaned all the schematics so that they are easily readable, compared to the faded copies i have now..

I Have Also Attached the copy of the first rom pair and the supposed addressing map in the hope someone may be able to help me out with option 2....

Edit1: Shrunk schematics,

[GeoffS]

Any chance of resizing the images to something manageable?

[Rerouter]

There You Go

[GeoffS]

 

[megajocke]

Hey, I have one of these beasts actually.

I don't have the manual so I'm not sure what it can do. Maybe I should buy one too. I have played with the controls a little but haven't been able to get it to do anything interesting, although the menus seem to work.

The plugin seems to be a 2 channel analog thing and is making a whining noise so I think there might be a problem with the isolated power supply in the plugin. (or maybe it is being shorted by bad tantalums)

[Rerouter]

megajocke the plugin is powered by the rear power supply, mine had some dud caps and i bet yours will have the same, (warning that the thing is voltage dependent)
(the rear supply can be tested while disconnected from the main system just give it in the ball park 50mA of load on the -15, +15 and +5V Rails, )

is there any remote chance of getting a copy of your memory cards prom?  i have a small arduino script i made up for unloading the thing if you have one...

[megajocke]

Thanks for the info. But what can this thing do? I don't really know anything about it and got it as non-working. It was going to be trashed but I rescued it because I thought I could make use of the vector display, but maybe trying to get it working would be more useful.

I'm currently away from home so can't do anything, but I could probably have a look when I get back.

[Rerouter]

its a universal waveform analyser, it is essentially a digital storage scope except it then can go and convert the output from the time domain to the frequency domain, so you see peaks at given frequencies, while seeing what a normal oscilloscope would also spit out, (my plug-in is 100 millions samples per second, so i very much want to see it revived)

also apparently it is meant to have a logic analyser plugin, but i have yet to find any info on it,

as far as the display goes, the display card has a crazy fast dac on it, but if you wanted to drive the display yourself, the plug that runs off to the display driver presents an X,Y and Z input, i think in the range of +7 to -14V,

I'll pm through to you the manual, it is a very powerful tool once working,

[Rerouter]

Some progress, 

I went over my code and quite literally had forgotten to carry the 2, 

So if a lurker ever needs it, here is the "S64 3.00" Prom Image
A0 is the right most, D3 is the Right Most

Code: [Select]

000000000 -> 1001
000000001 -> 1001
000000010 -> 0000
000000011 -> 1001
000000100 -> 0000
000000101 -> 1001
000000110 -> 0000
000000111 -> 1001
000001000 -> 0000
000001001 -> 1001
000001010 -> 0000
000001011 -> 1001
000001100 -> 0000
000001101 -> 1001
000001110 -> 0000
000001111 -> 1001
000010000 -> 0000
000010001 -> 1001
000010010 -> 0000
000010011 -> 1001
000010100 -> 0000
000010101 -> 1001
000010110 -> 0000
000010111 -> 1001
000011000 -> 0000
000011001 -> 1001
000011010 -> 0000
000011011 -> 1001
000011100 -> 0000
000011101 -> 1001
000011110 -> 0000
000011111 -> 1001
000100000 -> 1000
000100001 -> 0101
000100010 -> 1000
000100011 -> 0101
000100100 -> 1000
000100101 -> 0101
000100110 -> 1000
000100111 -> 0101
000101000 -> 1000
000101001 -> 0101
000101010 -> 1000
000101011 -> 0101
000101100 -> 1000
000101101 -> 0101
000101110 -> 1000
000101111 -> 0101
000110000 -> 1000
000110001 -> 0101
000110010 -> 1000
000110011 -> 0101
000110100 -> 1000
000110101 -> 0101
000110110 -> 1000
000110111 -> 0101
000111000 -> 1000
000111001 -> 0101
000111010 -> 1000
000111011 -> 0101
000111100 -> 1000
000111101 -> 0101
000111110 -> 1000
000111111 -> 0101
001000000 -> 0100
001000001 -> 1101
001000010 -> 0100
001000011 -> 1101
001000100 -> 0100
001000101 -> 1101
001000110 -> 0100
001000111 -> 1101
001001000 -> 0100
001001001 -> 1101
001001010 -> 0100
001001011 -> 1101
001001100 -> 0100
001001101 -> 1101
001001110 -> 0100
001001111 -> 1101
001010000 -> 0100
001010001 -> 1101
001010010 -> 0100
001010011 -> 1101
001010100 -> 0100
001010101 -> 1101
001010110 -> 0100
001010111 -> 1101
001011000 -> 0100
001011001 -> 1101
001011010 -> 0100
001011011 -> 1101
001011100 -> 0100
001011101 -> 1101
001011110 -> 0100
001011111 -> 1101
001100000 -> 1100
001100001 -> 1101
001100010 -> 1100
001100011 -> 1101
001100100 -> 1100
001100101 -> 1101
001100110 -> 1100
001100111 -> 1101
001101000 -> 1100
001101001 -> 1101
001101010 -> 1100
001101011 -> 1101
001101100 -> 1100
001101101 -> 1101
001101110 -> 1100
001101111 -> 1101
001110000 -> 1100
001110001 -> 1101
001110010 -> 1100
001110011 -> 1101
001110100 -> 1100
001110101 -> 1101
001110110 -> 1100
001110111 -> 1101
001111000 -> 1100
001111001 -> 1101
001111010 -> 1100
001111011 -> 1101
001111100 -> 1100
001111101 -> 1101
001111110 -> 1100
001111111 -> 1101
010000000 -> 0010
010000001 -> 0011
010000010 -> 0010
010000011 -> 0011
010000100 -> 0010
010000101 -> 0011
010000110 -> 0010
010000111 -> 0011
010001000 -> 0010
010001001 -> 0011
010001010 -> 0010
010001011 -> 0011
010001100 -> 0010
010001101 -> 0011
010001110 -> 0010
010001111 -> 0011
010010000 -> 0010
010010001 -> 0011
010010010 -> 0010
010010011 -> 0011
010010100 -> 0010
010010101 -> 0011
010010110 -> 0010
010010111 -> 0011
010011000 -> 0010
010011001 -> 0011
010011010 -> 0010
010011011 -> 0011
010011100 -> 0010
010011101 -> 0011
010011110 -> 0010
010011111 -> 0011
010100000 -> 1010
010100001 -> 0011
010100010 -> 1010
010100011 -> 0011
010100100 -> 1010
010100101 -> 0011
010100110 -> 1010
010100111 -> 0011
010101000 -> 1010
010101001 -> 0011
010101010 -> 1010
010101011 -> 0011
010101100 -> 1010
010101101 -> 0011
010101110 -> 1010
010101111 -> 0011
010110000 -> 1010
010110001 -> 0011
010110010 -> 1010
010110011 -> 0011
010110100 -> 1010
010110101 -> 0011
010110110 -> 1010
010110111 -> 0011
010111000 -> 1010
010111001 -> 0011
010111010 -> 1010
010111011 -> 0011
010111100 -> 1010
010111101 -> 0011
010111110 -> 1010
010111111 -> 0011
011000000 -> 0110
011000001 -> 1111
011000010 -> 0110
011000011 -> 1111
011000100 -> 0110
011000101 -> 1111
011000110 -> 0110
011000111 -> 1111
011001000 -> 0110
011001001 -> 1111
011001010 -> 0110
011001011 -> 1111
011001100 -> 0110
011001101 -> 1111
011001110 -> 0110
011001111 -> 1111
011010000 -> 0110
011010001 -> 1111
011010010 -> 0110
011010011 -> 1111
011010100 -> 0110
011010101 -> 1111
011010110 -> 0110
011010111 -> 1111
011011000 -> 0110
011011001 -> 1111
011011010 -> 0110
011011011 -> 1111
011011100 -> 0110
011011101 -> 1111
011011110 -> 0110
011011111 -> 1111
011100000 -> 1110
011100001 -> 1111
011100010 -> 1110
011100011 -> 1111
011100100 -> 1110
011100101 -> 1111
011100110 -> 1110
011100111 -> 1111
011101000 -> 1110
011101001 -> 1111
011101010 -> 1110
011101011 -> 1111
011101100 -> 1110
011101101 -> 1111
011101110 -> 1110
011101111 -> 1111
011110000 -> 1110
011110001 -> 1111
011110010 -> 1110
011110011 -> 1111
011110100 -> 1110
011110101 -> 1111
011110110 -> 1110
011110111 -> 1111
011111000 -> 1110
011111001 -> 1111
011111010 -> 1110
011111011 -> 1111
011111100 -> 1111
011111101 -> 1111
011111110 -> 1110
011111111 -> 1111
100000000 -> 1111
100000001 -> 1111
100000010 -> 1111
100000011 -> 1111
100000100 -> 1111
100000101 -> 1111
100000110 -> 1111
100000111 -> 1111
100001000 -> 1111
100001001 -> 1111
100001010 -> 1111
100001011 -> 1111
100001100 -> 1111
100001101 -> 1111
100001110 -> 1111
100001111 -> 1111
100010000 -> 1111
100010001 -> 1111
100010010 -> 1111
100010011 -> 1111
100010100 -> 1111
100010101 -> 1111
100010110 -> 1111
100010111 -> 1111
100011000 -> 1111
100011001 -> 1111
100011010 -> 1111
100011011 -> 1111
100011100 -> 1111
100011101 -> 1111
100011110 -> 1111
100011111 -> 1111
100100000 -> 1111
100100001 -> 1111
100100010 -> 1111
100100011 -> 1111
100100100 -> 1111
100100101 -> 1111
100100110 -> 1111
100100111 -> 1111
100101000 -> 1111
100101001 -> 1111
100101010 -> 1111
100101011 -> 1111
100101100 -> 1111
100101101 -> 1111
100101110 -> 1111
100101111 -> 1111
100110000 -> 1111
100110001 -> 1111
100110010 -> 1111
100110011 -> 1111
100110100 -> 1111
100110101 -> 1111
100110110 -> 1111
100110111 -> 1111
100111000 -> 1111
100111001 -> 1111
100111010 -> 1111
100111011 -> 1111
100111100 -> 1111
100111101 -> 1111
100111110 -> 1111
100111111 -> 1111
101000000 -> 1111
101000001 -> 1111
101000010 -> 1111
101000011 -> 1111
101000100 -> 1111
101000101 -> 1111
101000110 -> 1111
101000111 -> 1111
101001000 -> 1111
101001001 -> 1111
101001010 -> 1111
101001011 -> 1111
101001100 -> 1111
101001101 -> 1111
101001110 -> 1111
101001111 -> 1111
101010000 -> 1111
101010001 -> 1111
101010010 -> 1111
101010011 -> 1111
101010100 -> 1111
101010101 -> 1111
101010110 -> 1111
101010111 -> 1111
101011000 -> 1111
101011001 -> 1111
101011010 -> 1111
101011011 -> 1111
101011100 -> 1111
101011101 -> 1111
101011110 -> 1111
101011111 -> 1111
101100000 -> 1111
101100001 -> 1111
101100010 -> 1111
101100011 -> 1111
101100100 -> 1111
101100101 -> 1111
101100110 -> 1111
101100111 -> 1111
101101000 -> 1111
101101001 -> 1111
101101010 -> 1111
101101011 -> 1111
101101100 -> 1111
101101101 -> 1111
101101110 -> 1111
101101111 -> 1111
101110000 -> 1111
101110001 -> 1111
101110010 -> 1111
101110011 -> 1111
101110100 -> 1111
101110101 -> 1111
101110110 -> 1111
101110111 -> 1111
101111000 -> 1111
101111001 -> 1111
101111010 -> 1111
101111011 -> 1111
101111100 -> 1111
101111101 -> 1111
101111110 -> 1111
101111111 -> 1111
110000000 -> 1111
110000001 -> 1111
110000010 -> 1111
110000011 -> 1111
110000100 -> 1111
110000101 -> 1111
110000110 -> 1111
110000111 -> 1111
110001000 -> 1111
110001001 -> 1111
110001010 -> 1111
110001011 -> 1111
110001100 -> 1111
110001101 -> 1111
110001110 -> 1111
110001111 -> 1111
110010000 -> 1111
110010001 -> 1111
110010010 -> 1111
110010011 -> 1111
110010100 -> 1111
110010101 -> 1111
110010110 -> 1111
110010111 -> 1111
110011000 -> 1111
110011001 -> 1111
110011010 -> 1111
110011011 -> 1111
110011100 -> 1111
110011101 -> 1111
110011110 -> 1111
110011111 -> 1111
110100000 -> 1111
110100001 -> 1111
110100010 -> 1111
110100011 -> 1111
110100100 -> 1111
110100101 -> 1111
110100110 -> 1111
110100111 -> 1111
110101000 -> 1111
110101001 -> 1111
110101010 -> 1111
110101011 -> 1111
110101100 -> 1111
110101101 -> 1111
110101110 -> 1111
110101111 -> 1111
110110000 -> 1111
110110001 -> 1111
110110010 -> 1111
110110011 -> 1111
110110100 -> 1111
110110101 -> 1111
110110110 -> 1111
110110111 -> 1111
110111000 -> 1111
110111001 -> 1111
110111010 -> 1111
110111011 -> 1111
110111100 -> 1111
110111101 -> 1111
110111110 -> 1111
110111111 -> 1111
111000000 -> 1111
111000001 -> 1111
111000010 -> 1111
111000011 -> 1111
111000100 -> 1111
111000101 -> 1111
111000110 -> 1111
111000111 -> 1111
111001000 -> 1111
111001001 -> 1111
111001010 -> 1111
111001011 -> 1111
111001100 -> 1111
111001101 -> 1111
111001110 -> 1111
111001111 -> 1111
111010000 -> 1111
111010001 -> 1111
111010010 -> 1111
111010011 -> 1111
111010100 -> 1111
111010101 -> 1111
111010110 -> 1111
111010111 -> 1111
111011000 -> 1111
111011001 -> 1111
111011010 -> 1111
111011011 -> 1111
111011100 -> 1111
111011101 -> 1111
111011110 -> 1111
111011111 -> 1111
111100000 -> 1111
111100001 -> 1111
111100010 -> 1111
111100011 -> 1111
111100100 -> 1111
111100101 -> 1111
111100110 -> 1111
111100111 -> 1111
111101000 -> 1111
111101001 -> 1111
111101010 -> 1111
111101011 -> 1111
111101100 -> 1111
111101101 -> 1111
111101110 -> 1111
111101111 -> 1111
111110000 -> 1111
111110001 -> 1111
111110010 -> 1111
111110011 -> 1111
111110100 -> 1111
111110101 -> 1111
111110110 -> 1111
111110111 -> 1111
111111000 -> 1111
111111001 -> 1111
111111010 -> 1111
111111011 -> 1111
111111100 -> 1111
111111101 -> 1110
111111110 -> 1111
111111111 -> 1111

This means I'm back to either dead CPU, or dead ram,

So any thoughts on decoding the signatures?
and equally would dynamic ram need to be tested in any special ways considering it has a controller managing the refreshing

[Rerouter]

Finished decoding the addresses, apart from 2 oddballs,

ADDR 19 controls access to the memory card as a whole, when its high neither the ROM or RAM is visible to the system,
ADDR 18 controls whether its accessing ROM or RAM, with a high indicating ROM, and low for RAM,

17,16,15,14 all seem to be used to define which ROM chip or what RAM segment to access,

ADDR 17 = 0 | 16 = 0 | 15 = 0 | 14 = 0    // Access Rom 1

ADDR 17 = 0 | 16 = 0 | 15 = 0 | 14 = 1    // Access Rom 2

ADDR 17 = 0 | 16 = 0 | 15 = 1 | 14 = 0      // Access Rom 3
ADDR 17 = 0 | 16 = 0 | 15 = 1 | 14 = 1 

ADDR 17 = 0 | 16 = 1 | 15 = 0 | 14 = 0   // Access Rom 4
ADDR 17 = 0 | 16 = 1 | 15 = 0 | 14 = 1

All Remaining Codes Are Bus Error,

Now from this it seems that would cut the first 2 roms down to half there storage capacity, which puzzled me greatly until i noticed the first 2 pairs are only 8x8K EPROMS, allowing me to verify the contents of all the ROMs without removing them from the card,

Now onto RAM, as long as 17 is low, PROM0 = ADDR14, PROM1 = ADDR 15, PROM2 = ADD16.

ADDR 17 = 0 | 16 = 0 | 15 = 0 | 14 = 0 // 000
ADDR 17 = 0 | 16 = 0 | 15 = 0 | 14 = 1 // 100

ADDR 17 = 0 | 16 = 0 | 15 = 1 | 14 = 0 // 010
ADDR 17 = 0 | 16 = 0 | 15 = 1 | 14 = 1 // 110

ADDR 17 = 0 | 16 = 1 | 15 = 0 | 14 = 0 // 001
ADDR 17 = 0 | 16 = 1 | 15 = 0 | 14 = 1 // 101

ADDR 17 = 0 | 16 = 1 | 15 = 1 | 14 = 0 // 011
ADDR 17 = 0 | 16 = 1 | 15 = 1 | 14 = 1 // 111

The Remainder of the RAM address pins are exposed on the card, including a Write and Read Pin for the Dynamic RAM controller meaning i will be able to write and read back the RAM,

So this weekend I'll be testing both and could use any recommendations for a RAM test pattern?

Also i may as well note the 2 oddball addresses,
000000000 Accesses Rom 1, which goes against the ADDR18 convention, but i would believe this would have something to do with the boot routine?
111111101 Accesses RAM 111, which also goes against it, and cant really see any purpose for this

[Rerouter]

Following up on those 2 odd addresses,
000000000 was for the initial boot, it references 0x1FF worth of the first eprom, which contains all the interrupt vectors for the CPU,  and the program and stack pointer locations to start from,

and 111111101 is another 0x1FF long segment of RAM used for system registers,

Equally, i am up to testing, and am in the process of writing up the code for it,

what i have learned is that in order to read from the card in addition to the correct address, you need to hold MRDC (Inverted Memory Read) Low,
for the ROM you also have to pulse CCLK (normally 8Mhz clock signal, but no minimum in this case) 3 times to set up the ROM delay shift register,

for the RAM its only dependent on CAS and XACK being high on the Dynamic RAM Controller,

Writing to the RAM is equally simple, you only need to hold MWTC (Inverted Memory Write) low, and have a valid RAM address

Whenever an invalid Address is entered BBERR (Inverted Bus ERROR) will be pulled low, normally it is Tri-stated

[Rerouter]

Got a valid output, so while its running i felt i would post an update,

Now interfacing an arduino to a 20 bit address bus and 16 bit data bus is not something i felt i would ever be spending a Saturday afternoon on, but i present the fruit of my labors,



Here is what i breadboard up to break out enough pins, 3x 74HC595's driving the address bus, and 2 more 595's and 2 165's to make a bidirectional data bus,



Next up was a way to connect to the card, at 40 connections, it forced me to take a different approach, prepping solid core network cable while still in the outer sheath meant it was a lot easier to manage when connecting to the bread board,


Now onto the result as it stands,
ADDR00 serves no purpose towards the ROM segments, meaning its actual location gets shifted up a bit, making the interrupt vectors only 1FF long,

as for how it interacts with the RAM, its OR'd with the Write command for the lower byte of RAM, with BHEN doing the same for the upper byte, not something i understand yet,

The RAM i have yet to test, as I'm currently having it verify valid addresses, but it seems that every 64 RAM Addresses the default state alternates between FFFF or 0000, a quirk that i have yet to understand,

While only reading, the card pulls an average of 620mA @ 5V, on my revision board it needs no other supply rails, (3.1W, a bit higher than i expected..)

The actual address locations are
0x0 - 0x1FF = Rom Interrupts (Bootloader)
0x40000 - 47FFF = ROM (Starts with Rom 1 Image)
0x50000 - 53FFF = ROM (All Rom Space Accounted for)

0x200 - 0x7FFF = RAM
0x10000 - 17FFF = RAM
0x5CF00 - 5FDFF = RAM (All 16x64K Accounted for)

Once i work out the RAM testing part of the code, I'll post it in-case anyone else gets stuck like me,
 
Edit: See following post for address locations

[Rerouter]

Have made some more progress, for writing to RAM i need to source a bigger power supply, as after 40 seconds of what ever pulse loads it was pulling my supply was going into thermal shutdown (probably around 1A)

I am currently diagnosing my transceiver circuit as it seems to not be driving into the data bus and fear i could be driving the cards outputs, but will crack it sometime tommorow,

[Rerouter]

After rewiring some parts of my breadboard, I finally managed reliable read/write   
Biggest addition was 10K lift-up resistors on the data bus, this made it far more clear where the segments began and ended
equally further study revealed ADR00 has to be pulled high, and BHEN low for memory writes,

The Address Map as it stands now is:
0-1FF is still interrupt vectors,
200-FBFF is RAM,
FC00 - FDFF is a bus error  (011111100 on PROM)
FE00 - FFFF is the remainder of this chunk of RAM,
40000-4BFFF is system ROM
5FC00 - 5FDFF is RAM (System Registers)

which adds up for all the ROM and makes more sense, but leaves a small 1FF Gap missing from the RAM,

for the power supply, i ended up grabbing one of these from jaycar, http://www.jaycar.com.au/productView.asp?ID=XC4258
works very well for bread-boarding , just approaching too hot to touch at 700mA for long periods of time

So far the memory is looking ok write/read back and decay wise, and i am nutting out the code for testing for overwriting neighboring cells, here is the code as it stands, its a bit of a beast now, with common tasks broken into voids, and a few remaining variables for what i am working on, but it works.

Code: [Select]

unsigned long DAT = 0;
  unsigned long ERRDAT = 0;
  boolean flag = 0;
  unsigned int RangeStart = 0;
  unsigned int RangeStop = 0;
  boolean prevfault = 0;
 
               // 2x 74HC595
  byte DI_PL = 2;          // Parrellel Load
  byte DI_CLK = 3;         // Shift Clock
  byte DI_SI = 4;          // Serial Data Input to Arduino
               // 3x 74HC165
  byte AD_SO = 5;          // Serial Address Output From Arduino
  byte AD_SCLK = 6;        // Shift Clock
  byte AD_LCLK = 7;        // Output Latch
               // 2x 74HC595
  byte DO_SO = 8;          // Serial Data Output From Arduino
  byte DO_SCLK = 9;        // Shift Clock
  byte DO_LCLK = 10;       // Output Latch
  byte DO_OE = 11;         // Output Enable
               // Card I/O
  byte MEMR = 15;          // Read From Memory Signal
  byte MEMW = 12;          // Write To RAM Signal
  byte CCLK = 14;          // ROM Delay Clock, Needs to be pulsed 3 times for valid output
 
  void setup(){
    // Parrellel to Serial Data (00:15)
  pinMode(DI_PL, OUTPUT);   // Parrellel Load
  pinMode(DI_CLK, OUTPUT);  // Clock
  pinMode(DI_SI, INPUT);    // Serial In
 
    // Serial To Parrellel Address (00:19)
  pinMode(AD_SO, OUTPUT);   // Serial Out
  pinMode(AD_SCLK, OUTPUT); // Shift Register Clock
  pinMode(AD_LCLK,OUTPUT);  // Latch Clock
 
    // Serial To Parrellel Data (00:15)
  pinMode(DO_SO, OUTPUT);    // Serial Out
  pinMode(DO_SCLK, OUTPUT);  // Shift Register Clocl
  pinMode(DO_LCLK, OUTPUT);  // Latch Clock
  pinMode(DO_OE, OUTPUT);    // Output Enable

    // Card I/O Signals
  pinMode(MEMR, OUTPUT);     // Memory Read (Inverted)
  pinMode(MEMW, OUTPUT);     // Memory Write (Inverted)
  pinMode(CCLK, OUTPUT);     // Clock for ROM Reading Delay (3+ Clocks for valid output)

    // Bus is normally high,
  digitalWrite(MEMR, HIGH);  // Turns off Card Read
  digitalWrite(MEMW, HIGH);  // Turns off Card Write
  digitalWrite(DO_OE, HIGH); // Disable outputs of data write, to prevent outputs driving outputs
  Serial.begin(115200);
  }
 
 
  void loop() {
    // Testing for decays
    Serial.print("Testing Short Decay 00200-0FBFF FFFF");
    Serial.println("");
    ShortDecay (0x200,0xFC00,0xFFFF);
    Serial.print("Testing Short Decay 0FE00-0FFFF FFFF");
    Serial.println("");
    ShortDecay (0xFE00,0x10000,0xFFFF);
    Serial.print("Testing Short Decay 5FC00-5FDFF FFFF");
    Serial.println("");
    ShortDecay (0x5FC00,0x5FE00,0xFFFF);
   
    Serial.print("Testing Long Decay 00200-0FBFF FFFF");
    Serial.println("");
    Verify     (0x200,0xFC00,0xFFFF);
    Serial.print("Testing Long Decay 0FE00-0FFFF FFFF");
    Serial.println("");
    Verify     (0xFE00,0x10000,0xFFFF);
    Serial.print("Testing Long Decay 5FC00-5FDFF FFFF");
    Serial.println("");
    Verify     (0x5FC00,0x5FE00,0xFFFF);
   
   
    Serial.print("Testing Short Decay 00200-0FBFF AAAA");
    Serial.println("");
    ShortDecay (0x200,0xFC00,0xAAAA);
    Serial.print("Testing Short Decay 0FE00-0FFFF AAAA");
    Serial.println("");
    ShortDecay (0xFE00,0x10000,0xAAAA);
    Serial.print("Testing Short Decay 5FC00-5FDFF AAAA");
    Serial.println("");
    ShortDecay (0x5FC00,0x5FE00,0xAAAA);
   
    Serial.print("Testing Long Decay 00200-0FBFF AAAA");
    Serial.println("");
    Verify     (0x200,0xFC00,0xAAAA);
    Serial.print("Testing Long Decay 0FE00-0FFFF AAAA");
    Serial.println("");
    Verify     (0xFE00,0x10000,0xAAAA);
    Serial.print("Testing Long Decay 5FC00-5FDFF AAAA");
    Serial.println("");
    Verify     (0x5FC00,0x5FE00,0xAAAA);
   
     
    Serial.print("Testing Short Decay 00200-0FBFF 5555");
    Serial.println("");
    ShortDecay (0x200,0xFC00,0x5555);
    Serial.print("Testing Short Decay 0FE00-0FFFF 5555");
    Serial.println("");
    ShortDecay (0xFE00,0x10000,0x5555);
    Serial.print("Testing Short Decay 5FC00-5FDFF 5555");
    Serial.println("");
    ShortDecay (0x5FC00,0x5FE00,0x5555);
   
    Serial.print("Testing Long Decay 00200-0FBFF 5555");
    Serial.println("");
    Verify     (0x200,0xFC00,0x5555);
    Serial.print("Testing Long Decay 0FE00-0FFFF 5555");
    Serial.println("");
    Verify     (0xFE00,0x10000,0x5555);
    Serial.print("Testing Long Decay 5FC00-5FDFF 5555");
    Serial.println("");
    Verify     (0x5FC00,0x5FE00,0x5555);
   
       
    Serial.print("Testing Short Decay 00200-0FBFF 0000");
    Serial.println("");
    ShortDecay (0x200,0xFC00,0x0);
    Serial.print("Testing Short Decay 0FE00-0FFFF 0000");
    Serial.println("");
    ShortDecay (0xFE00,0x10000,0x0);
    Serial.print("Testing Short Decay 5FC00-5FDFF 0000");
    Serial.println("");
    ShortDecay (0x5FC00,0x5FE00,0x0);
   
    Serial.print("Testing Long Decay 00200-0FBFF 0000");
    Serial.println("");
    Verify     (0x200,0xFC00,0x0);
    Serial.print("Testing Long Decay 0FE00-0FFFF 0000");
    Serial.println("");
    Verify     (0xFE00,0x10000,0x0);
    Serial.print("Testing Long Decay 5FC00-5FDFF 00000");
    Serial.println("");
    Verify     (0x5FC00,0x5FE00,0x0);
    }
   
  void ShortDecay (unsigned long Start, unsigned long Stop, unsigned int Data) {   // Writes value, reads it back and compares
    prevfault = 0;
    for(unsigned long ADDR=Start; ADDR < Stop; ADDR++) {             // Write 1 to every location 
      flag = 0;
      Address(ADDR);                                                 // Write out the current address
      DataOut(Data);                                                 // Write out a test value to RAM
      RAMIn();                                                       // Read back in value from RAM
      if(DAT == !Data) {                                             // Test to see that it matches
        flag = 1;
      }
      if(prevfault == 0 && flag == 1) {                              // Determine Range of Fault to reduce serial comms usage
        prevfault = 1;
        RangeStart = ADDR;
      }
      else if (prevfault == 1 && flag == 0 || prevfault == 1 && ADDR == (Stop-1)) {
        RangeStop = ADDR;
        prevfault = 0;
        PrintRange(RangeStart,RangeStop,0);
        RangeStart = 0;
        RangeStop = 0;
      }

    }
  }
     
     
   void Verify (unsigned long Start, unsigned long Stop, unsigned int Data) {  // Reads back value and compares
    prevfault = 0;
    for(unsigned long ADDR=Start; ADDR < Stop; ADDR++) {             // Write 1 to every location 
      flag = 0;
      Address(ADDR);                                                 // Write out the current address
      RAMIn();                                                       // Read back in value from RAM
      if(DAT == !Data) {                                             // Test to see that it matches
        flag = 1;
      }
      if(prevfault == 0 && flag == 1) {                              // Determines range of fault
        prevfault = 1;
        RangeStart = ADDR;
      }
      else if (prevfault == 1 && flag == 0 || prevfault == 1 && ADDR == (Stop-1)) {
        RangeStop = ADDR;
        prevfault = 0;
        PrintRange(RangeStart,RangeStop,1);
        RangeStart = 0;
        RangeStop = 0;
      }
    }
  }
       
  void Print (unsigned long ADDRP, int error) {                         // Prints the address and read data of an error
    if       ( ADDRP < 0x10   ) { Serial.print("0000");}                // Adds leading 0's
    else if  ( ADDRP < 0x100  ) { Serial.print("000"); }
    else if  ( ADDRP < 0x1000 ) { Serial.print("00");  }
    else if  ( ADDRP < 0x10000) { Serial.print("0");   }
    Serial.print(ADDRP, HEX);     
   
    Serial.print(" => ");
    if      ( ERRDAT < 0x10  ) { Serial.print("000"); }                 // Adds leading 0's
    else if ( ERRDAT < 0x100 ) { Serial.print("00");  }
    else if ( ERRDAT < 0x1000) { Serial.print("0");   }
    Serial.print(ERRDAT, HEX);
   
    if      (error == 0) { Serial.print("   Quick Decay");              }  // Prints Error Type
    else if (error == 1) { Serial.print("   Slow Decay");               }
    else if (error == 2) { Serial.print("   Overwrote Near Neighbour"); }
    else if (error == 3) { Serial.print("   Overwrote Far Neighbour");  }
   
    Serial.println("");
  }
 
  void PrintRange (unsigned long Start, unsigned long Stop, int error) {  // Prints the range of an error
    if       ( Start < 0x10   ) { Serial.print("0000");}                  // Adds leading 0's
    else if  ( Start < 0x100  ) { Serial.print("000"); }
    else if  ( Start < 0x1000 ) { Serial.print("00");  }
    else if  ( Start < 0x10000) { Serial.print("0");   }
    Serial.print(Start, HEX);     
   
    Serial.print(" to ");
   
    if       ( Stop < 0x10   ) { Serial.print("0000");}                  // Adds leading 0's
    else if  ( Stop < 0x100  ) { Serial.print("000"); }
    else if  ( Stop < 0x1000 ) { Serial.print("00");  }
    else if  ( Stop < 0x10000) { Serial.print("0");   }
   
    Serial.print(Stop, HEX);   

    if      (error == 0) { Serial.print("   Quick Decay");              }  // Prints Error Type
    else if (error == 1) { Serial.print("   Slow Decay");               }
    else if (error == 2) { Serial.print("   Overwrote Near Neighbour"); }
    else if (error == 3) { Serial.print("   Overwrote Far Neighbour");  }
   
    Serial.println("");
  }
 
   
  void Clock(int Pin) {                                              // Rising Edge Clock Function
    digitalWrite(Pin, LOW);
    digitalWrite(Pin, HIGH);
  } 
       
   void Address(unsigned long ADR) {                                 // Shift In Address
     for(unsigned int A=0; A<21; A++) {                              // ADDR0 is ignored so data is shifter up 1,
       if(bitRead(ADR,(19-A))== 0) { digitalWrite(AD_SO,HIGH); }     // Address bus is inverted
       else                        { digitalWrite(AD_SO,LOW);  }
       Clock(AD_SCLK);                                               // Clock Shift Register
     }
     Clock(AD_LCLK);                                                 // Latch Output of shift register
   }   
   
       
   void ROMIn() {
     digitalWrite(MEMR, LOW);                                        // Tells the card data will be read
     Clock(CCLK);                                                    // Enables read output latch on card
     Clock(CCLK);
     Clock(CCLK);
     Clock(CCLK);
     Clock(DI_PL);                                                   // Load the contents of the bus
     for(int D=0; D<16; D++) {                                       // Clock in the data on the bus
     bitWrite(DAT, (15-D), !digitalRead(DI_SI));
     Clock(DI_CLK);                                                                   
     }                                                                       
     digitalWrite(MEMR, HIGH);                                       // Tell the card its no longer being read from
   }
   
   void RAMIn() {
     digitalWrite(MEMR, LOW);                                        // Tells the card data will be read
     Clock(DI_PL);                                                   // Load the contents of the bus
     for(int D=0; D<16; D++) {                                       // Clock in the data on the bus
     bitWrite(DAT, (15-D), !digitalRead(DI_SI));
     Clock(DI_CLK);                                                                   
     }                                                                       
     digitalWrite(MEMR, HIGH);                                       // Tell the card its no longer being read from
   }


   void DataOut(unsigned long DATA) {                                // Shift out data
     digitalWrite(DO_OE, LOW);                                       // Enable Shift Register Outputs
     for(int D=0; D<16; D++) {                                       // One by one clock out 16 bits
       if(bitRead(DATA,(15-D)) == 0) { digitalWrite(DO_SO,HIGH); }   // Bus is inverted
       else                          { digitalWrite(DO_SO,LOW);  }
       Clock(DO_SCLK);                                               // Clock the shift Register
     }
     Clock(DO_LCLK);                                                 // Clock The latch
     digitalWrite( MEMW, LOW);                                       // Tell the card its being Written to
     digitalWrite(MEMW, HIGH);                                       // Tell the card its no longer being written to
     digitalWrite(DO_OE, HIGH);                                      // Tristate shift register outputs   
   }
if anyone can think of other tests i can perform on this board before i call it working, it would be appreciated