And we can see the address here and we can see the memory contents here in this video.

What I want to do is do something similar for the actual data that were storing in memory.

So right now we have these eight bits, which right now I've just connected down here, too.

Looks like they're all set the ones, but instead, we want to connect these to to some sort of input that's either going to take the data to store off the bus or take it from dip switches.

So very similar to this.

And so again, we're going to use the 74 Ellis 1 50 seven's to switch between the dip switches and the bus for the data that we're storing in memory.

And so again, we want to give ourselves a little bit more room.

So going to use another Fred board here, and I'm gonna connect it right here because we're gonna do this right below here.

Actually, I'm also going to connect below this the instruction register, which we built in a previous video on.

We're not really gonna be using the instruction register at all for this, But just when we put the final computer together, this is a good place for it.

So we'll just we'll just have that there.

So, like I said, what we want, we want some dip switches here when we're in programming mode will be able to set the address here, will be able to set the data here to write data into memory on.

And that's how we get our program into memory before we actually start running things on the computer and then to switch between using the switches to program the computer and actually being able to let the computer put things in its memory on its own.

From the bus, we want to use those 74 l s 1 57 chips that we that we looked at in the last video eso It has these A and B in puts in a Y output, and you select between A and B using the select pin here.

Since we have eight bits here instead of the four.

Instead of using one of these chips Will will need to And we'll start, of course, by hooking up the power and ground for each of these chips.

And then just as we did up here, we have this pin 15 which is the strobe input connected to ground on.

And that's essentially just kind of an enable line for the whole chip.

So whenever that's low, the chip is enabled.

So go ahead and connect pin 15 here to ground.

And this one's gonna be a little bit tricky because I have these ladies in the way.

But let me pull this out for a moment, and we can kind of slide that in and the lady back in there, hopefully in the right place.

Okay, so that's hooked up and the next What I'm gonna do is I'm gonna connect the outputs four lines on the cheese we have total of eight lines that were selecting between either the dip switches or we'll be the bus that we and connecting into the B inputs here.

But first I'll start with connecting the outputs of these into the data inputs of our memory so that whichever source were selecting from the output is going to go into our memory.

So we're writing that debt bite into memory.

Okay, so I think that is everything that we can pull these out.

And now all of the outputs of R R selectors, uh, should be going to the data inputs of our memory, so we should be able able to.

Well, once we hook up our dip switches and our bus, we should either either be able to program the memory from the dip switches or, you know, data coming in from the bus should be able to find its way into the memory.

It's not hook up the dip switches.

It's gonna be very similar to what we did up here.

Which is we're gonna be using the dip switches to connect the the The again puts on both of these two ground.

When the switch is on s O, for example, this will connect the A input of this first, uh, this first bit for the sort of the most significant bit here to ground when the switch is on.

And, of course, for that to work, I need to connect this side of it to ground.

So when that on, then it connects ground toa at input.

And then when it's off, it's disconnected.

Which means that the imports gonna default toe high because all of the inputs on these on these have a pullup resistors built into these chips.

If it's not connected, the input will be high on again, just like we did here, because it's kind of un intuitive for the switch to be down, meaning high and up, meaning zero so down as a one up is a zero.

I'm gonna just flip this switch upside down.

So that way, when the switches air down, they're on.

And then when we flip the switch up, the switch turns off.

And so when it's off, it's not connected to ground, which means it's gonna be a one.

And when it's on when it's down, it is connected to ground and it's a zero.

So go ahead and connect to the rest of these and, of course, for these inputs up here, then I'll just connect the connect him through to switch the other way and connect the grounds down here, and then they just connect up into these pins up here, then turned around the wires back and forth.

Okay.

And that should be connecting our dips, which is up to the A inputs of of the 74 less 1 57th Now the be inputs of the 74 less 1 50 seven's.

So the inputs are when we're in programming moods and programming mode.

We set our address here.

We said our our data value here and then we can right using this signal and we'll look up a push button for this in a moment.

Use this signal to put whatever value we sat here into the address that we said here, and that's how we programmed the computer until we put data into the into the memory before we start the computer.

When we go into run mode, then when we want to write data into the memory, it's gonna be coming from the bus and the bus.

And then when we wouldn't want to read data from memory, it goes out to the bus through these tri state buffers.

But to get data in from the bus, we want to bring that down into the B inputs of our 74 Ellis, 1 57 R selectors.

Here, I'm gonna go ahead and hook that up now.

Okay, So that now connects the bus, which which is gonna be connected here on these eight bits that that extends that bus into the selectors here.

So that'll be the normal run mode.

But then Lauren, programme mode instead of reading data from the bus will be reading data from our dips, which is here.

And so the way the programming will work is will we'll switch over to programme mode, set the address.

We want a program here, set the data that we want to put in that address here, and then we want a toggle.

Our right, of course to do that would be nice to have a little push button switch.

So I've got that here.

You stick that in there, and so this will just be a little button that we can push to write the data.

So once we put the address that we want to write it too, and put the data here, push that button and I will write it to to there.

But of course, again, we want to be able to switch between using this button to write to memory and the computer being able to have a control signal that's gonna come from the control logic of the computer to tell it that we want to write data into memory s Oh, this this right signal that's going into the memory now, um, has to be switched depending on whether we're in programme mode or not s o.

Of course, to do that, we're going to use another 74 Ellis 1 57 which I'll put it right here.

So this right signal is gonna come from the output of one of the one of the selectors in this 1 30 in the 74 Ellis 1 57 um, actually should have maybe connected our power here first.

Get that underneath There's power and coarse ground.

And then again, pin 15 of this 74 last 1 27 is the essentially the enable signal.

So if we want to set that low so that the CIP is enabled a low active low signal there so that that's that.

And so when Warren programme mode, we want the this push button to essentially take the program sitter the right signal here low whenever we push it.

So we'll connect the switch from from ground through the switch and then into the a input of our 74 less 1 57 And so they input is is the input that will be using when we're in programme mode and then when we're in run mode, um, this could be a little bit different in run mode, we wantto essentially take the signal from from the control logic.

So the control logic in the computer which will get to in future videos a TTE some point Well, programs are executing.

It's going to say, Hey, I want to write to memory.

So it'll it'll set this right signal.

Um, but we don't want it to necessarily right immediately when the right signal gets set because we want the right signal to say Okay, on the next clock cycle, we're gonna write to memory.

But then we have wanna wait for that clock cycle.

So really, we want the right signal to be a combination of the right signal from the control logic as well as the clock signal, um, and actually specifically the rising edge of the clock.

So what?

I'm gonna dio is essentially and together using an and gate the clock signal and the control signal saying that we want to write to memory.

So when you use a 74 l s 00 which which actually is not an and gate, it's a NAND gate.

And the reason I want a NAND gate is because this is an active low.

So AnAnd Gate is gonna say when the right signal is high and the clock signal is high, then output zero and zero is the thing that that tells the memory the 74 Ellis 1 80 nine's in this case, too, actually, uh, you know, take the data from the bus and write it.

So first, let me hook up the power for the 74 l s 00 the NAND gate.

We're just gonna use one of the nan gates on here.

Is the pin out is pin one and pin to or the inputs and pin three is the output.

So I'm gonna hook pin three here over here to the B input of our selector.

So hook that to the B input of our of our selector.

So whenever this nand gate is outputting a zero and we're in run mode.

Then the selectable will feed that zero on through to the memory and we'll we'll end up writing whatever whatever date is coming in.

So one of these inputs is going to be the control signal that's coming from our our control logic, which will you touch on in a horrible.

We'll build it in a future video and go into it.

So when that's low, then we're not writing.

And then if that goes high, then we will be writing something into memory.

Um, so have that low.

The other input is going to be from our clock.

Go ahead and connect this up to our clock signal.

Just kind of bring that.

Bring that back down here.

And so this is saying when the clock is high and our right signal is high, then this goes low, which then has passed through.

I think we can go ahead and test this out on, see, see what happens.

Have we power it up?

Yes, we can see our clock is running there and we see.

Of course, we have some random random data here.

If we go into right mode, we can set our address.

So if we said the address zero, this should, right?

Whatever value we have on our dip switches, here's we have all zero.

So we hit that.

Nothing happens.

Oh, of course.

So we don't We're not actually selecting here.

I neglected to to connect to the actual select pins.

Remember these 74 less 1 50 seven's?

We want to select whether we're programming or writing.

And of course, we have this hooked up pin.

One is the select opinion you can see Pin One here is connected over too.

This red led, which goes low when we go into into right mode.

We need to bring that that signal down here so that when we switched to write mode, uh, these guys are also selected, and right now it's only disconnect power and go ahead and do that into that should tie all of our select CE for all four of the 74 less 1 57 to 3 down here in the one up here, too.

The same switch years.

And so I think that should be almost everything for the Ram module.