So, ever since we made that video on core memory,
with Carl's IBM ferrite core memory plane, I wanted to have my own and display them
properly. So I bought some from - turns out there's some that are available on eBay
for quite a reasonable price - from Russia. Russia used core memory far longer
than we did here in the West. And I found two of them and I put them in this
magnificent plexiglass breakout boards. So I just took some plexiglass, I think that's
from [the] Container Store, and then added some banana plugs around - I'll show you how they
are connected - and put a little protector, so you don't hold - you protect the back of the
array and don't break it. So I have two planes, one is a 4 kilobits that was probably part of
4 kiloword array with many of those stacked, one for each bit. And I have a smaller one, it's
one kilobits. If you have not already done so, I recommend you watch first the core memory
explanation video. But I'll give you a quick redux here to bring you up to speed. The
scheme that became the main computer memory technology from the 1950s all the way to the
mid 1970s was invented by Jay Forrester at MIT, and first demonstrated in the Whirlwind computer
in 1955. In fact, here is an original Whirlwind core plane and the actual Whirlwind core memory
stack, now at the Computer History Museum. In core memory, the bits are held by the
magnetization state of tiny ferrite cores. These can be magnetized in two orientations:
clockwise or counterclockwise. You magnetize them by running currents through wires that go
through them. Addressing wires are in a regular XY matrix. The combined currents through the wires
has to be higher than a threshold value for a core to flip its magnetization, a property that's
used to address a single core in the matrix. There is also a global sense wire used for
reading and a global inhibit wire for writing. Note that sensing signals are only generated
when a core flips. So reading a bit consists in setting a core to zero, and see if
it causes a sense signal indicating a flip. By the same token this erases the
bit. Therefore reading is destructive and every bit that is sensed has to
be rewritten immediately afterwards. So the idea is that they both look pretty and
presentable, and now you can hand them to people, and they are protected on both sides by
plexiglass. But it's also functional so that it's actually you break out with
banana plugs to a few X and Y wires, and I also have the sense and inhibit,
so we can actually flip some cores. And to make them work we are going to use our
two HP pulsers, and that's the main reason why I bought the extra HP 8082 pulser and repaired
it in the previous videos. So the first thing I had to do, is figure out what weave pattern
was used. In this one, there are 4 sub-panels, 4 sub-arrays of 1k each, and X and Y pattern
runs pretty much through all the 4 sub-arrays. And I had to figure out what the inhibit and
sense wires do. And the inhibit is pretty straightforward, snakes around. There
is first one wire that I put in red, that goes through half of the core and
then there's a little splice at the end, which you can see, and then it comes
to the blue wire and comes back here. It turns out there are two sense wires,
there is sense A and sense B. And sense A, if you follow the wire, you see that it goes
out [at] half of the array then goes in the opposite quadrant and then it comes
back and covers the rest of the array. So, sense A does two sub arrays, and sense B is
another wire that does to other sub-arrays. So the way I wired this one, I picked two X and
Y lines that are in this quadrant over here, so I can read them with sense A. I
nevertheless have sense B over here. I also have inhibit. So two Y and two X, so
we can flip four bits in that giant 1k memory. The second array is more traditional,
it's just one big array here. And on this one, it's kind of weird: you have one
sense wire that does three quarters of the array. It starts over here - that's the red one - and
comes out over here. And you have another one, the blue one, that only does a corner of the
array. I'm not too sure why they did that, but anyhow, what I ended up doing
is completing the turn here and having those shorted. So I have one wire
that does all the sensing in the array. Same thing, I had two X wires, I have less
space in that one, so I have just one Y wire. The inhibit is over here, and here's the
sense that I have put in one single loop. So the first thing I need to figure out is
the current at which the cores flip magnetic polarity. And for that I'm going to use
two short pulses of opposite polarities using my two pulsers. So the first one
is going to come from the bottom one. And let's - we use the magic button
to make the edges not too steep so we reduce the amount of picked up noise from
anything else that's not a fast core flip. And then I'm going to trigger the second generator
off the first one - did I do this right? Yeah - and get my second pulse. So there are two things
I want to do to this pulse: I want first to have it in the other polarity - so that's easy, turn it
to negative - and then I need to delay it, so it arrives after the first one. And that's the magic
delay that I repaired in a previous video. And there you go. So that's - now you guys understand
why I wanted that delay to work so badly. So that's going to be one set pulse and one reset
pulse, and we are going to figure out how to combine them, and how to make a current driver out
of it. So I want the two pulses on the same wire, and for that I need a little combiner circuit
which I made quickly right here. And all that does is: I have the pulse coming from the two
generators and I have two 25 ohm resistors. So as far as the generator sees it, it's just
terminated by 50 ohms, which is what it should be. And when this one pulls up, the signal comes
through the diode from the ground through the 50 ohm resistor. When this one pulls down it comes
through that diode and through the two resistors, and here I should get bipolar pulse
combined with half the amplitude. And that's this magnificent circuit
over here which we are going to hook up. And... Trigger... There we go. And
here are our two pulses. I need a little bit of adjustment. There we go.
So next up, I need to amplify the pulse, because I expect the flipping to happen at the
current anywhere from 500 milliamps to an amp. And for that I'm going to continue piling
on the HP equipment, and use this baby here, the 6824 DC power supply amplifier. And what this
is, is a bidirectional power supply. You can use it as such, and you can have it go from - 60
volts to plus 60 volts. But you can also put it in the amplifier mode. And in that mode
it basically tries to match the voltage at the output of the power supply to the input
that you give it. And it's medium-ly fast, I think it goes to a few tens of kilohertz, so
that should be perfect for our use. And on the output I have a 10 ohm resistor, so I get 1 volt
for every 100 milliamps, so I can easily test it. And if I turn the gain on, here's my directional
output, and I actually calibrated my probe so it reads directly in milliamps. There's a little
setting on the scope that allows you to set the probe to read milliamps. In my case it's 10
volt per amp. You can see it in the corner. So I'm already at half an amp. And if I push it, I'm
going to go to one amp. And since it's pulsed and it's mostly idling, the core memory won't get hot
at all. So now the output pulse goes through the resistor so I can measure it, then back through
one line. And to see what we are doing I'm going to monitor the inhibit line. And what that guy is
going to do, is that we are going - one of these lines, I'm going to flip them all at the same
time, and then the inhibit line should pick it all up. So I'll have many, many cores flipping at the
same time so I should have a fairly strong signal. Off we go. All right. So nothing goes. All
right, 80 milliamps, 200 milliamps, 250 - oh there it goes! There we have it. You see the
cores flipping? And that's at 380 milliamps. So about 400 milliamps. Okay. So our cores
are flipping about 400 milliamps. All right. Now that we have a good idea
of what our current should be, we can go and build our little current driver.
Here's the Skookum version. Current drivers rely always on the same principle. Somewhere
you put a resistor to sense the current, and then you have some feedback loop that
ties on that. So here let's imagine we want 500 milliamps to be driven through the load
through the transistor. And we put a 10 ohm, so it will have 5 volts over here. And if the
transistor is driven by an op-amp, and you put 5 volts at the input, it will try to get this
point also at 5 volts, to balance everything. So this one will guarantee you a 100 milliamp
per volt input, perfectly. And if you want to do it the simpler, non-Skookum way, you can do it
just this way with a bipolar transistor. Where the same sensing resistor is here. And basically
this point will adjust at 0.6 volts - the drop of the base emitter junction - above, so if I put
5.6 volts over here I'll have 500 milliamps. The final version is actually a little bit more
complicated. So I have a resistor to match it to basically 50 ohm impedance, a little bit more, but
approximately. And I have a switch so I can easily invert the polarity of the signal so I can set and
reset the cores. Easy circuit to prototype, there it is. And then when I make sure it works, I like
to build permanent version. So Adafruit are these things that look like breadboards and you can
actually solder it. And I make my little circuit, it will fit on this smaller board. And once I
have put all the components at the right place, I just need to build them. So it's pretty
simple. So let's just go wire this up. Okay. So I'm all hooked up with the Y driver,
the X driver, and I am actually measuring the pulse straight off the current sensing resistor,
so I am actually calibrated directly in milliamps. If I get that guy up. There it is. Ah, it
won't quite go there the whole way, need to get to the next range. Here. 300 milliamps on the
X and 300 milliamps on the Y. So now, we're going to see if we can read something from the cores.
And for that, I am going to hook up to sense A, my sense wire. And that's the blue trace - you
can see it actually. And what you see are not the cores flipping quite yet. What you see is these
stray signals picked up from the transition. So I need to slow them down, until - there you
go - until they are slow enough that they don't induce parasitic currents. And that's where
the HP 8082 really shows it's mettle. There we go. So now they've disappeared. I am
going to go into manual. All right, manual, okay. So I give it one pulse at the time manually.
So I can now give them pulses manually. So, if all is working fine, I just give it a
pulse that's more than it takes to flip a core at the coincidence. If I reverse
polarity I'm going to flip it in the other direction. So I reverse polarity
in the two wires, give it another pulse. Oh, there we go. And then you see - oh it's pretty
right actually. Right somewhere in the middle of the second pulse, it's enough to flip the core.
And if I read it a second time, it's gone, because it only reads the flips. The read is
destructive in core memory. After you [read] it you have to [write] it again. So now we have
flipped it in the other direction, and if I read it after flipping... Ah, something happened, I'm
not getting the current I'm supposed to get here. There you go. And you see that it went - so it
flipped the other direction. So, one of my switch didn't switch quite correctly. Let's try it again.
So that's one direction. Read again, it's gone. Flip it, and here we see it. Read again, it's
gone. So I'm actually quite pleased with this. This four wire system is a lot less noisy
than the three wire system that IBM used. Just gives me a really clean signal. Now if
you look at it, it's very small. This is 10 millivolts. So this is like a 15 millivolt
spike. So if we want this to be usable, we need to add one more thing to bring it to a
logic level. And that "one more thing" is this little circuit here, which is the sense amplifier
that we made when we were working on the AGC. And this is actually made with period amplifiers.
Three circuits in one: it's an amplifier, it's a threshold detector, and it's a pulse flipper.
It puts all - whether it's negative or positive, the pulse is always positive at the output.
Here it is all wired up. Sense coming now to the amplifier, and the output comes to the
scope, which is now back on two volts per division. So we should have now a big fat logic
signal. So I pulse it and flip it. There we go, we get a nice big pulse here. Nice and fat.
And then if I re-read it, it's gone. But now if I flip it in the other direction, instead
of having a negative pulse as I had before, this one flips it up. So I always have
a signal showing in the right direction, no matter what the flip is, if
it's up to down or down to up. So now that we have it
working kind of beautifully, we can start to reduce our cycle time.
I can reduce the pulse with. Make them a little steeper. See if it - so now
I'm taking adventure of the threshold. See, yeah, there we go. Still flippin'. So we
have done like three months of research in five minutes, thanks to our good equipment here.
Okay, so now we are back into a reasonable time frame. We are at 500 nanoseconds per
division. So actually that's very good, I never had core memory work this fast.
Woohoo. Well I cannot go much faster than the core itself, so the core takes about
300 nanoseconds. So we have a one and a half [microsecond] time in here. That's
not bad at all. It's very clean flips. So now that we are optimized, let's see if we
can prove that we can read and set two bits independently. So I'll set the bit on this line
and let's set the other bit on this other line. Okay, it was the other polarization,
so we reset our two bits. So now, I should be able to read that one without
destroying the other one. So I read this one, now I destroyed it, it's gone. And I go to the
other one, which is on the same vertical line, right. But it shouldn't have been destroyed
because the currents were not coincident. So I should be able to read it. And there it
is! So I have independently set two bits, read bits separately on the same row,
thanks to coincident current addressing. We should be all good to go. Oh, so, this
one is - look at that - it's... Okay. So, I see the bit flipping. So we see several
things here. This one is way more sensitive to the edge, so I need to go back to an
un-optimized setting here with much bigger pulses. There we go. So I need to go to very
slow edges. There we go. So this one will work a lot slower. Interesting. And actually
I would have expected denser one to pick up more of the stray signal. But no. This
one is more sensitive to stray signals. I don't know why. So that's entirely in
the weave, it's not due to the cores. Flip it, there it is. All right! So that's it for playing
with core memory, and as you can tell, it takes a lot to get core memory working.
So you can imagine what those people went through to make their computers working, and
what a revolution solid-state memory was in 1974 when Intel introduced it. Right.
Thanks for watching, see you next time! But before we leave there is something else that
I want to show you, that we are lucky to have today. And I wanted to make a video on [it], but
because of the Covid situation we have not been able to do it. [music: Halleluyah] And this is
a piece of the LVDC computer memory. So that's the Launch Vehicle Digital Computer, that's the
computer that was piloting the Saturn V. And we of course got it on loan. I can't remember the
size of this thing, maybe 8k, something like that. I need Ken Shirriff. He did all
the reverse engineering. So I'll make a video when we can get together again.
