And in this video, I want powered up, test it out and basically convince ourselves that it's working.

Right.

So we'll powered up and it's on.

You see, the clock is running and we're gonna switch to programme mode.

And so we have all zeroes here.

We have all zeroes here, so if we push the button in programme mode, it should write all zeros to memory.

And okay, we're making progress.

All right, so it looks like we wrote, um I think I see what's going on.

Oh, boy.

So I'm just looking clothes very closely here and what I see.

So first off, I guess the kind of explain what's going through my mind here.

So we wrote zeroes here.

We did not.

We were once here.

And whenever you see one's one thing to kind of think it may be a possibility, is that you No one is sort of the default input.

So if something's not connected, do you get a one?

Because all the inputs on all these 7400 Siri's something for L s.

Siri's chips are pulled up thio like pullup resistors on the inputs.

So that makes me think that, you know, maybe this is hooked up sort of correctly, because we could test that, actually, if we maybe set that.

Yeah.

So if we set that bit, it's writing that there.

We turn that off.

It's not writing it.

But no matter what, we set these two, I'm guessing it won't change.

Yeah, so that doesn't that does.

Nothing happens there.

So that makes me think that we got this hooked up, right?

We don't have this hooked up.

Right?

And the first thing that I noticed, um, just just inspecting it.

I see that, um, I am I might be off by by a couple are off by one here to the power.

Should be going to pin 16 here.

And I see it's going to pin 15 and then also this this ground should be going to pin 15.

Looks like it's going to pin 14.

But then I would expect Oh, yeah.

Okay, so I do have to do with this this input from the dip switch a bit too comes across and that goes to pin 15.

Of course, you can see That's correct.

But just these two wires are are just off by one.

So I just need to shift these over to the left.

So let me pull the power.

Often do that.

So this shift over and of course, you know, if this if this chip wasn't powered, which it wasn't, you know, the power was not connected.

This has fallen out.

Who, boy?

Um, yes, that this chip wasn't powered than you know.

It's outputs would be would be floating and the inputs on these chips default toe ones.

And so whenever we do a write, it just it just writes all ones.

So that explains the behavior that we saw.

Now I need to figure out howto more.

Find a good place for this ground.

Okay, look, I get it to reach.

Looks like that'll work.

Okay, let's give this dry.

So if we power it up, we get some random stuff in memory there.

But with these all zeros, if we write, we get all zeros.

So looks like that might have fixed it.

So let's try setting a different pattern in here and write that.

Okay, Looks like we write that.

And if we switch to address one.

We get some other random garbage.

And if we go toe all zeroes here and right there, then we got all zeros.

We go back to address zero.

We should see.

Yep.

We see that pattern.

That's an address.

Zero.

And it's one we got an address to.

We get random stuff, but we could put in, you know, some other pattern like that.

We go back to address zero.

We see that would address one.

We get zero.

So looks like we are able to put whatever data we want into memory by selecting the address here, selecting the data we want here and pushing this button here to write that data in that address.

So now we gotta run mode than we should be now, using the memory address registered here, and it looks like that's pointed to address zero.

And so we're seeing what's in address zero.

There.

Now, this case we want to go to address one we've got to kind of set are, uh, you know, the one on the bus here.

So we want to set these top three bits to zero, and then, of course, the bottom that will default toe one when we when we said our read signal here.

So this is our read and actually stop the clock for a second here.

So if we say we wantto right, I guess from the from the registers perceptions were gonna write to the bus 1000 s o.

If we set this enabled there than on the next clock pulse, we got a one in our address register.

And of course, we see the zero because we have a zero in that location of a memory.

If we want to go back to address zero, then we have to set all four of these bits low.

So let's go ahead and set that fourth bit low.

And so this signal is still in putting a ah, right signal.

So on the next clock pulse that should put a zero into the register here, and that goes to zero.

And we see the memory that the data that's in that memory location zero.

And we could try going to memory address, too.

And on the next clock pulse Uh, oops.

Did I?

Oh, I just have these wires mixed up.

Put these in the right order here.

I'm not confused.

Here we go.

So this should be addressed to on the next clock pulse yet puts a to there.

And then this is the data that we had stored in address location, too.

So it looks like the memory address registered is working.

Um, that's great.

Now, if we want to read this data from the bus or read this data and put it on the bus again, we're gonna connect the bus over here and we could hook up some led is just tow to see for now what's over here.

And like I did before, I was gonna connect three of these ladies just to give us an idea.

So everyone output Well, right now we have a location to in our address register.

And if we want to take the data that's in location to put that on the bus, then that's this signal.

Here we take that low and we see what least the bottom three bits.

It looks like we're out putting that.

And I guess we could We could move this, led here and see Yeah, that fourth been is is set there.

And then the fifth bit should be off six bits should be off seventh bit should be upon and the eighth bit should be off.

Okay, so it's looks like it's out putting this thing onto the bus when we tell it to.

And then when we tell it not to, it doesn't.

So then I think the only other thing we want to test is make sure that when we want to take data from the bus and put it into memory that we conduce that.

And so in that case, I'll take these ladies out of the way, and I'm gonna use thes wires here to put a value on the bus.

So again, you know these air gonna You're gonna default.

Hi.

So I'm just gonna set a couple of these.

I'm gonna set this second bit low and let's say the third bit low.

Ah, maybe sixth bit low and the seventh bit low.

Just those four bits I'm gonna set low.

And then I'm going to use this signal down here, which is our right signal.

So you know, we've got this address.

One in the memory.

I just register.

So we see what's in memory.

Location one.

Here.

We saw that we get out.

Put that to the bus.

Now we have a value that a different value that one input from the bus in store in that memory location.

And so if the control logic of the computer wants to do that, then it would set this high to say I want to write to memory.

Uh and then on the next clock pulse, which you can see all of this I'm gonna just pulse the clock here and we should see this new data go into memory.

And there it is, so that new data is in memory.

Oh, it's something Something interesting happened here.

You see, the address changed tall ones.

And that's because we're also writing to the memory address registered normally.

That would never happen because he wouldn't write to the memory address said Richer and the data at the same time, you'd want Thio to do one of the other.

So let me back up a second and turn off the writing to writing the data to memory.

Then I want to go back to address one.

Actually, let me just double check here Address to that.

Looks like it wrote it there, too.

We'll go back actually Might mean what would be easier here is is we can use this reset signal and just reset the address here.

So we're we're at address zero.

Um, and we want to not write to the address registers.

I don't want to change the address.

We only want to change the contents at that address who wanna stay on address?

Zero.

And then we want to write to that address this data until then, on the next clock pulse.

Yes, It writes this data into memory.

So I'm reasonably convinced that this is working now.

You know, it's not a total test of every connection, so there might be like, one bit that's not hooked up quite right on.

And we'll probably find that later on when we start hooking everything up together and running more complex programs, things we'll see some subtle issues which are always fun to troubleshoot.

But at least a day east, at a quick, a quick sort of test, it looks like everything is working more or less the way that we want.

One other thing I'm gonna do just this kind of ah, convenience thing is, we've got all these little control signals everywhere.

I'm gonna I'm gonna label them just to make life a little bit easier for me.

So we go up to the clock.

This signal here is the halt signal.

I'm just gonna stick a little label there That says this is This is Holt, which holds the clock.

This is the memory address register in signal eso.

When this is when this goes low, we're gonna input a value into the memory address register.

So I'm gonna call that m i for memory address register in.

And I got the bar there because it's, ah, active love.

So normally want that high?

This is the ram out signal.

So when this is when this goes lenses inactive low.

When this goes low, it outputs the contents of RAM to the bus.

So, Mark, that is roo for ram out.

And that's active lows.

I will keep that high normally.

And then, of course, to input from, uh, input from the bus to Ram.

We've got the ram in signal down here, so I'll Mark that is our eye for Ram Inn.

And that's active high.

So I don't have the bar there.

So normally that will be low unless we're inputting from Ram and then while we're here, Since we got the instruction register down here, I'll label those as well.

This is the instruction register out.

So this will output Whatever's on the in the instruction register to the bus.

So that's the io, and that's an active low.

So normally that'll be high.

Unless we're out putting the contents of the instruction registered to the bus had finally the instruction register in S O.

This will input data from the bus and store it in the instruction register.

And that's also active low.

So that's I I and that normal, that'll be high.

And actually, one last thing that I want to d'oh which is when were for the Ram in when we're writing data from the bus into ram which will notice if we set this highs.

Who Ram inn when the clock signal goes high, you see that this is all zeros and that's because when the clock signals Hi, we're writing for the entire duration of the clock signal.

Hi.

Really, What we want to do is write just on the leading edge of the clock.

So right now we're Nanjing, the clock and the ram in signal can't quite see that We're standing the clock and the ram in signal.

So this this white pin one here is the clock and this is the ram in signal.

But really, what we want to do is we wantto look at the ramming signal and just the leading edge of the clock and just a TTE that moment where the clock goes high, not the entire time that it's high.

We want to.

Actually, that's That's the moment that we want to read data from the bus and put it into into ram here so we could do a really simple edge detector circuit by pulling this pin lo and then instead of in putting the clock directly into that pin.

If we if we go through a capacitor, then what will happen is this will only be high for the time it takes the capacitor to charge through this resistor.