DIY Dynamic RAM from scratch with Capacitors and Diodes

Indexed: 2026-05-15

[00:00:00]All right, now it's the next day.

[00:00:03]And uh let's see what these if these capacitors are still holding charge.

[00:00:11]They sure are.

[00:00:14]And the power's been off.

[00:00:21]Same pattern as I programmed into them yesterday.

[00:00:25]That's pretty good.

[00:00:26]That's almost like RAM.

[00:00:31]But here's a little capacitor experiment. We have a 1,000 microfarad capacitor.

[00:00:35]The positive end going to these two buttons, one that turns it off, one that one that turns it off, one that turns it on.

[00:00:43]And this is this button is connected to the ground of the capacitor. And then the output is going through this LED driver.

[00:00:51]So, this is what makes the capacitor um able to function.

[00:00:58]Right? So, I could without the ground being on, um if I ground the capacitor now, there's nothing in the capacitor because it would show up in the LED. Um I could, without grounding it, turn this LED on, so theoretically all the positive >> [clears throat] >> uh charge should go into the capacitor.

[00:01:22]However, because it wasn't grounded, if I ground it now, nothing happens.

[00:01:28]Um but if I pre- ground it and then press the positive, now the capacitor has all the charge stored in it. It's charged up instantly.

[00:01:43]Now, if I want to discharge the capacitor, if I try to turn this off while it's not grounded, and I press that button and try to ground it, it's still fully charged.

[00:01:55]Um so, in order to discharge it, I have to press this button while it's grounded.

[00:02:02]And in that way, the capacitor becomes addressable as a uh something to store a bit.

[00:02:13]So, right now, it's got a zero in there. But, if I want to change it to a one, I do that, and now, it's got a one in there.

[00:02:24]Every time I read it by grounding it, um, it's got a one. So, that leaves us to the ability to address individual capacitors within a RAM uh capacitor memory array.

[00:02:44]Now, to make this more complicated, I've added this second capacitor. So, both the positive sides of the capacitor are connected [clears throat] to this um bit line, which uh gives it a plus or a minus, or a one or a zero. And the negatives of these two capacitors are connected to these separate two buttons.

[00:03:06]So, in this way, this is address the first address, this is the second address. So, um if I want to see what's on the capacitor now, I press the second address, and that one's storing a one. And the first one also storing a one. Now, let's make it uh this one store a zero.

[00:03:28]So, discharge that. Now, zero, one. And let's switch that over now.

[00:03:38]So, make that a one, and make that a zero. So, now, when I press this, it's zero. When I press this address, it's one.

[00:03:48]And so, in that way, we have one bit line >> [clears throat] >> with two addresses.

[00:03:53]And these are the storing charge. Um and without them being grounded, the the charge gets just trapped in here.

[00:04:02]Um so that is how we're going to slowly build a memory array. Now what I've done is I've attached the second bit line uh and same address on the negatives.

[00:04:18]And let's see what happens.

[00:04:22]Um so this controls the second bit line, and so let's address this first set of capacitors and put one there.

[00:04:32]You see both of them go on. And that's not supposed to happen.

[00:04:36]And when I put when I address the second one, I just want this one off and this one on.

[00:04:45]But you see how both of them go on.

[00:04:50]Um so it's erratic behavior. The charge gets spread across.

[00:04:55]Um I could turn them both of them off.

[00:04:58]Um and that one and this one, both of them are on. But let's turn this one off.

[00:05:05]And now when we address it, we get that.

[00:05:08]When we address this one, we still have the negative. Let's put that on there.

[00:05:13]And as you can see, the charge gets spread across both. So when you address each of these, um it changes to whatever is on the other one.

[00:05:30]So that is why we're going to need diodes to um direct the traffic of uh the charge current um in the appropriate direction so that um the charge sharing doesn't happen amongst the capacitors.

[00:05:50]So now, I've uh gotten rid of all the capacitors except one. And what I have is the negative side of this electrolytic capacitor connected to ground via these two diodes going in opposite directions. The one going towards ground is the right diode, and the one going away from ground is the read diode. This is equivalent to putting them in the opposite direction to the positive end.

[00:06:17]So, um this is the this connected to this bit to this uh uh LED.

[00:06:24]So, to read it, let's Well, let's see.

[00:06:27]If I hit the right one, let's see what happens. Nothing.

[00:06:32]If I read it, nothing. There's nothing there.

[00:06:36]Okay. Now, if I want to press read, and I turn this on and write to it, the light goes on, but if I read it with that off, nothing happens.

[00:06:53]So, in order to write to it, I have to press the right one, which activates this diode, connects that, [clears throat] and I'm going to press it one there.

[00:07:06]Now, when I read it, if I hit right again, nothing happens.

[00:07:11]Um but if I read it, light's up.

[00:07:16]And so, using these diodes, these capacitors become individually addressable.

[00:07:22]Um and they won't share any uh charges cuz they have their own individual um grounding diodes.

[00:07:34]So, let's test that out with a 2x2 array.

[00:07:38]So, this is the setup I'm going to use to test out a 2x2 capacitor RAM array.

[00:07:44]So, now I have the 2x2 array.

[00:07:47]And um and each one each of these capacitors has its own read and write diodes.

[00:07:55]Um so, the write button is there, read button is there for address mo- two. Address one, write button, read button, and then this controls the bit uh line for uh bit one and bit two.

[00:08:12]So, bit one and bit two are the LED drivers here. So, as of now, let's read what's in there.

[00:08:19]So, that has a value of 01 at this address. And let's read this one.

[00:08:24]And this has a value of 10.

[00:08:27]So, now let's change that by turning off the one and writing in a one here.

[00:08:41]Okay, now we'll read that.

[00:08:46]Button's a little sticky here. There it is.

[00:08:49]Okay.

[00:08:50]And this value, let's get rid of that one and put it in the first bit.

[00:09:00]Nope.

[00:09:00]Can't I got to write it to the first bit.

[00:09:03]So, now when we read that, it's 10 on address one and 01 on address two.

[00:09:11]And in this way, using these diodes, this individually allows individual addressing through a single word line, which is an address line, and it's got a separate write and read and for each address.

[00:09:26]And so, in that way, we can use signals to control that um to make an upscaled version of this 2 by 2 uh dynamic RAM array and make it into something bigger.

[00:09:45]Before I do that, I'm going to introduce the concept of a sense amplifier, which is basically a static RAM memory cell using two inverters. Uh but I'm going to implement that with two MOSFETs as inverters, as you can see in the circuit here.

[00:10:02]So, this is basically a sense amplifier. It's a two transistor static RAM cell.

[00:10:14]And basically two set up is two inverters, transistor-based inverters.

[00:10:19]And uh the output is looped back on itself, so it latches.

[00:10:25]So, the other output is going to this uh LED driver here, another transistor.

[00:10:30]And so, using this wire, if I just push it on, it latches on.

[00:10:42]So, whatever data value, whether it's high or low, gets latched. And when I turn it off by grounding it, it stays. So, it's basically a static RAM cell.

[00:10:56]Um and what it does is it just amplifies the data bus signal coming in.

[00:11:11]So, here's our 2 by 2 array incorporating a sense amplifier for every bit line.

[00:11:18]And as you can see here, uh if I read the top address, uh the data value is 1 0, and the bottom address, um the value is 0 1.

[00:11:30]Uh the only And I don't have to keep pressing the button in order to have the data displayed. It just latches on with the sense amplifier and by reading it, it basically feeds back charge into the capacitor circuit so it refreshes it while it does that. Um, the only issue with this is that to you have to de-latch um unlatch the stored data and um in order to do that, you actually have to turn it off and on. Um, otherwise if you read the two different uh areas of the data at the same time without unlatching them, you see they both latch on and that's not exactly what we want. And that extra step of having to turn it off is [snorts] not ideal.

[00:12:31]So, as you could see here, um rewriting the data uh for each address line and all those extra steps of turning it on and off at each point um makes it cumbersome and it's difficult uh to do.

[00:12:51]But here, the data values on the top address are rewritten >> [clears throat] >> um to what the bottom address was and vice versa.

[00:13:06]So, in order to fix the latching and de-latching problem uh the first thing I wanted to do was replace the grounding buttons for the reads and writes at each address line with a way to trigger the read and write with the just a positive going signal.

[00:13:22]Um so I could use a button here and the way I did that was to replace it with transistors.

[00:13:30]Um MOSFETs for the rights and regular NPN transistors for the reads.

[00:13:38]And in this way, I can get a digital signal to trigger the address changes for the reads and the writes. And here it is implemented on the 2 by 2 array.

[00:13:49]And subsequently, I have it on a perf board for full eight addresses that I made.

[00:13:57]Then next, um in testing this out, what I realized that when uh pressing the right of a separate address where the transistor or the bit line is off, would de-latch the previously addressed uh bit value.

[00:14:18]And then reading it would rewrite it onto the data bus. So, um in this way, a single signal delivered to the read and write with the read being delayed by a fraction of a second, would de-latch the previous data value and re-latch the new value on the new address that's being addressed with a single signal at each address point.

[00:14:48]So, this is the final circuit of the 2 by 2 array with the sense amplifiers drawn in.

[00:14:55]And the address lines controlled with a signal from the left side.

[00:15:02]And here it is being tested out with just wires being plugged into the positive rail and switching the 0 1 at address 1 and the 1 0 at address 2.

[00:15:15]And then subsequently, I attached it to >> discharges right buttons where you could see the the transistor addressing and the two long wires, the black wire and the blue wire with the various buttons being pressed at address zero and address one.

[00:15:33]And and there are the sense amplifiers on the left side of the screen and the two buttons controlling the different addresses and those are positive going signals that trigger each individual address.

[00:15:53]So, now we're going to scale up our 2x2 array, which uh has served us well for testing and design purposes to a full uh array of eight bytes of dynamic RAM memory using these capacitors. I had decided to build this in a modular fashion with the RAM array and the control elements with separate modules that I could just interconnect.

[00:16:24]This way I'm going to try it out first with out the sense amplifiers and then add those in.

[00:16:33]So, here's my capacitor RAM or dynamic RAM using just capacitors.

[00:16:41]And I have eight bytes here and I've programmed some values in and they're going to be read out on the um the LED's here and I have read and write. So, these are the write column and this is the read column.

[00:16:57]And so, I have some pre-programmed values here and they're all different. And if I press read these are all on.

[00:17:07]Next byte.

[00:17:10]And that.

[00:17:13]That.

[00:17:18]That.

[00:17:20]We're going towards the middle. Then I have a random one.

[00:17:26]F1 and X.

[00:17:29]Then I have that.

[00:17:32]This is 1010 with AA.

[00:17:35]And this which is 55.

[00:17:39]And X.

[00:17:40]And So, let me use this address.

[00:17:53]Uh let me see this one.

[00:17:56]Let's see something like this. Nope.

[00:18:00]That one.

[00:18:02]And that one.

[00:18:04]Yeah, that one. And I'll light up the two in the middle.

[00:18:07]So, to do that, I'm going to put on the two ones in the middle.

[00:18:13]Oops.

[00:18:15]Those are not the middle.

[00:18:19]This is going to be a pain in the butt.

[00:18:30]I'm going to write it to address [clears throat] two.

[00:18:34]So, here it goes.

[00:18:35]And I hit the right button for address two.

[00:18:41]Now, I'm going to turn this off. This is basically the data bus.

[00:18:46]And let me read address two.

[00:18:49]Now, it's those two bits that are lit.

[00:19:00]And the RAM value is still stored in the capacitors.

[00:19:06]Address zero through address seven.

[00:19:10]And uh and these are the bit lines and they're all cross connected.

[00:19:16]It works beautifully. Dynamic RAM using capacitors.

[00:19:22]So now I'm going to add in the sense amplifiers in order to allow automatic refreshing of the capacitor charge every time the data value is read. So it'll be like a read write refresh cycle.

[00:19:39]Um and additionally even though these capacitors hold store charge for a long time cuz they're large um we need a value a way of doing this in order to truly make a dynamic RAM array.

[00:19:57]Now I've created a set of eight sense amplifiers.

[00:20:01]And what they do is they take the signal that's coming on the bit line and every time you read it, it refreshes it.

[00:20:11]And so with the capacitor RAM it almost never goes off. It's almost basically non-volatile.

[00:20:19]So if I was going to go to address one then you get the floor the pattern of hex 55 and and address two I have hex AA set.

[00:20:37]That's AA.

[00:20:40]And that works. And if you look at what the oscilloscope is reading it's at 5.1 volts which is refreshed with the sense amplifier.

[00:20:54]Now I just need to make the control signal happen.

[00:21:00]Now the only thing left to add here is the control signal that um de-latches the latched data of the previous address and re-latches it by combining the read and write signal into a single um positive-going signal.

[00:21:18]As you could see from the capacitor the 2x2 array experiments, um pressing the right um will de-latch the data on in from the previous address from any other address except for the one except for if the bits are also lit on the next address.

[00:21:40]So, um here it is demonstrated once again in terms of how the signal has to happen.

[00:21:50]Right.

[00:21:52]And read.

[00:21:53]And write again.

[00:21:55]If I hit read on the first one, they all light up.

[00:22:05]And that's how it works.

[00:22:09]So, once again, by combining the read and write signals uh in a write followed by a slightly delayed read with that uh resistor, you get a single addressable signal that automatically triggers the data to be displayed the minute a upcoming um uh trigger on the address is made.

[00:22:37]I did this using diodes here, but um and the reason for that is because I wanted to leave the initial uh the initial write and read individual signals um intact and alone. That way they could be triggered from an outside source such as uh uh a different integrated circuit that's trying to write to the RAM address or uh read from the RAM address.

[00:23:04]And here you could see I'm switching between address zero and one quickly just with a wire connected to the positive rail.

[00:23:12]Um just going back and forth quickly.

[00:23:15]And it's working pretty well.

[00:23:19]Here's the final product.

[00:24:16]And that controls all of it.

[00:24:21]Including the sense amplifiers.

[00:24:29]And it's just a one button push.

[00:24:55]And there it goes.

[00:24:57]Thank you guys for watching. Hope it was enjoyable.