Continued testing of the 1130 MRAM Core Memory Replacement board

SWAPPED IN THE HC CHIP VERSION FOR 3.3V SUPPLY

I had installed 7400 series chips (and other types) on the board that were able to work on a 3.3V power supply, but a recent switch from an AND to a NAND gate, open collector, I put in 74LS03 which require a minimum of 4.75 VCC. The 74HC03 parts arrived last night and were installed on the board. 

TESTING ON THE BENCH

I am working to rigorously test the PCB while on the bench before I install it on the IBM 1130 system. I wanted to write to different memory addresses using unique data values, then test by reading the locations and comparing the returned values. 

I whipped up some code on an Arduino Due (because it uses 3.3V logic levels), expanding on my previous code that generated the correct timing of Storage Read and Storage Write signals that would come from the IBM 1130. These alternated for 1.8 microseconds duration. I stored fourteen addresses and corresponding data values in the program then stepped through the list cyclically. At the start of a Storage Read it sets the memory address (and data value for the upcoming write). The Sense pulses are generated during the Storage Read and then the location is updated during the Storage Write. 

I used direct port mapping to write the pins since the DigitalWrite function is relatively slow. The Due requires that a 1 be written in one control register to turn on a pin, but it doesn't turn off it 0 is written there. Instead, a 1 has to be written in a different control register that clears pins. 

After the first pass, the memory would have had all locations set up with the prepared values from the program. I would then set the scope to trigger on Storage Read rising edge or an address bit rising edge and monitor three output lines from the board at a time. Due to limited pins on the Arduino, I couldn't simultaneously produce the 16 B register data values, the 13 SAR address values and capture the 16 Sense pulses to verify. 

With just 3 pins that I can monitor at a time on the scope, I had to be clever to test the correct data returned from each location. These are open collector inverted outputs, thus a 1 bit pulls its pin to ground else it is pulled up to 3.3V using a resistor.

The addresses I chose were 0, 1, 2, 4, 8, 16, 32, 64. 128. 256, 512, 1024, 2048 and 4096. I can uniquely trigger on those addresses except for address 0. The values written were 1 through 14 decimal in sequence. 

I had previously validated that all 16 sense pulses are generated when the corresponding bit was written in memory, also that all 16 of the data value (B reg) bits were stored in the memory words. This is just a test to be certain that we are addressing memory correctly. Any result of 0 detects an addressing or write failure. 

When I tried to observe the outputs from the Arduino I found that it just could not keep up with the 1.8 microsecond durations of the memory cycle. To get reliable results, I had to slow it down to 1.8 milliseconds for read and 1.8 milliseconds for write. That won't stop my memory board from working, since my logic triggers on the edge of the read or write signal and its not sensitive to its duration. 

The connections using jumper wires are a bit fragile, thus I had to deal with some erratic results. More frustratingly, I would sometimes turn on the +12V bench supply and see zero current being drawn. The wire connection on my PCB showed 3.3V which is the correct output of the regulator, so I didn't understand why this was happening. 

UNDERSTANDING THE WEIRD RESULTS

The power confusion is due to the ability of the voltage regulator to buffer quite a bit of energy, when combined with the very low draw of my board, so that it can sit drawing zero power from the bench supply for long periods. 

I then realized that the slow speed I set up for alternating Storage Read and Storage Write cycles didn't completely solve the glacial relative speed of the Arduino compared to my board. I saw that the delay from when I set Storage Read high until the main loop of the software set the Storage Address Register and B Register outputs to the board was approximately 6 microseconds. I was already using direct port mapping for speed but the problem is that the read is accomplished rapidly and the output is provided from my board in about 800 nanoseconds (0.8 microseconds) thus the data being read does not have the proper address yet. 

The residual address from the prior pass of the Arduino code is what the MRAM is reading, not the one I intended. I checked a few cases and felt comfortable that this is why I see the wrong bit being output for a given address.

WILL REWRITE THE ARDUINO DRIVING PROGRAM

I cannot use the timer based 1.8 microsecond or even the drastically slowed 1.8 millisecond control signals because the Arduino can't set up all my outputs in time for the very fast board circuitry. Instead, I will use the Arduino at its native speed to set up the SAR and B values, then toggle the Storage Read and Storage Write signals from the code. 

Specifically, I will split the program into one that only does Storage Reads in order to observe with the oscilloscope as above. The other version of the program will execute one pass writing the intended values into memory.