Name: Subroutine calls, now with RAM — 6502 part 7
Uploaded: 2020-03-27T17:47:40.000Z
Duration: 17 min 42 s
Description: Thousands of YouTube videos with English-Chinese subtitles! Now you can learn to understand native speakers, expand your vocabulary, and improve your pronunciation...

building a simple computer based on the 65 02 processor.

Adverbs of manner

And in previous videos we got it working and actually displaying some text.

But then we tried to simplify the code to use subroutines.

It stopped working, and it's not working because when the computer jumps into a subroutine, it pushes the return address on to the stack, which is in memory.

And at the end of the subroutine, it pulls that return address off the stack so it can jump back from where it came.

Our problem is that our computer didn't actually have any ram in it.

So in the last video, I started hooking up this Ram chip here, and I've got the 15 address lines.

Is green wires here hooked up to the address bus, The eight data lines, the blue here hooked up to the data bus and the right enable pin, which is this yellow wire underneath here that goes all the way over, hooked up to the reed right pin on the microprocessor, and that's hooked up pretty much like this.

We've got the 15 address lines, we've got the eight data lines, and we've got the read write or a right, enable signal hooked up here.

But then the Ram chips got a couple of control signals here is well to enable it.

And for that we said, Well, we can hook those up to address 14 and 15 so that when both of those air low, the ram is enabled, and that'll ensure that the ram is enabled anytime the addresses between 0000 and three f f f, which is the range we want to use for the ram.

But then, in the last video, we took a closer look at the timing diagram for the Ram to take a closer look at the timing requirements for interfacing with it.

And then we looked at the timing diagram for the microprocessor as well.

It's kind of the interaction between these two.

And so that was That was in the last video, and what we found is that this wouldn't actually work quite like this.

Instead, we have to add a little bit of logic here, and this is to ensure that the chip select signal doesn't go low until all of the address lines are set and stabilized, and then the chips like signal would go high before any of the address lines change anytime we're doing a read or write, particularly a right to the ram.

And so that's what this additional logic here does.

And in my last video, I went over exactly why we needed this.

So in this video, let's hook this this extra logic up and see if we get the ram working.

I'll start with the address 14 and hook that around to the output enable.

And we're gonna take that to output enable over here.

And so this will ensure that the ram is not gonna output anything unless address 14 is low, which it has to be.

If we're addressing anything in that zero through three FFF address range, then we need to hook up the chip select, and the Chip Select is going through these logic gates now conveniently, we already have one of the logic.

It's hooked up already because we have this address 15 being inverted through an and gate like this that we already did for the chip Select for the rahm.

And so address 15 is coming down here and this is actually I just 15 here and it's connected.

And if you can see, it's connected to both inputs of one of these Nan Gates.

And in the output here is ah is going back up around a chip select for the rum.

But we can reuse that to go to one of the inputs of this other Nan Gates.

I'll just hook from the output of that first NAND gate to one of the inputs of the next man gate with just a little tiny jumper there.

And then this neon gate, the output of that will go to the chips elect of the Ram.

That's gonna be the output of this nan gate here has got to go all the way around to the chip Select input of the Ram.

And I've got a nicely measured wire that I need to somehow speed through here and there we go.

So we've got one of the inputs going into this neon gate and then we've got the output going around to the chip select over here, and then the other input is gonna be our clock signal and already got the clock signal hooked up here.

Coming from the clock pin of the processor around to the clock in put down here of the interface adapter.

And what I'm gonna do is I'm gonna pull this this longer, wire out and replace it with two shorter wires so we can drop it into this NAND gate and put here as well, we'll pull that clock wire out and we'll come from the processor down to that input on the NAND gate.

And then we'll have another shorter wire that goes from that important an and gate around to the interface adapter Luck.

So that restores that same connection we have before.

But now we have also have a clock input going into the NAND gate There.

Now I'm using three of these Nan gates, and I'm not planning to use the fourth Man gate.

And it's a good practice when you're not using inputs to tie them either high or low.

So they're not floating and potentially hovering between high and low and causing the chip to switch on and off, in which get introduced noise and such into into the rest of the circuit.

So it's just a good practice to tie those unused inputs high.

But with that, you know we've got Let's see, we've got address 14 now hooked output enable We've got address.

15 already was being inverted by this first NAND gate.

And now that's going into the second Man gate as well as the clock going to the second and gate.

And then the output of that NAND gate is coming all the way around here to chip Select.

So with that, we should now have RAM in our computer, which also means we should now have a stack in our computer.

So let's ah, let's go ahead and try to power it up and see if our program works.

Because if we have a stack our program out of work, plug this in and so your clock is running, will reset.

And, yeah, there we go, our partners working.

And I haven't changed the program in the room.

So it's using the jump to subroutine instruction and obviously the return from subroutine instruction, which is what wasn't working before.

And it appears to be working now, which which is great.

So, yeah, let's take a closer look at that.

Let's ah, let's get this out of the way and I will hook Thea Arduino back up so we can actually monitor step by step and see that stack operation again.

So like before, I'll start by hooking up all 16 of the address lines to 16 inputs of the artery.

No, and then we'll hook up another eight inputs of the Arduino to eight of the data lines.

And then we'll hook up the reed right signal from the processor to to another input and, of course, hook up the clock to another input on the Arduino to trigger it.

And then finally, we need a common ground.

And it's pretty annoying to hook up, I have to say, but in any event, I will hook up the Arduino to the computer and power up the computer.

Other computer reset here and her program's running, but I'm going to, ah, hold down, reset and stop the clock.

That way, we'll be able to a single step through this and see what's going on.

No serial monitor and all good and clear that in this hard we know program that I'm running well, actually, let us see what's on the data and an address buses for each clock cycle.

And you can check out a previous video where I talked more about how it works really well.

Step through the 1st 7 clock cycles to let the processor initialize itself and then the next to clock cycles, reading FFC Enough 50 that reads The Reset Vector, which is 8000 and we'll jump to 8000 We'll start reading instructions.

So a two is the load X and an F f so that loads ff into the ex register.

And this is initializing the stack pointers because the next instruction is gonna be our transfer X two s and that's Ah nine a.

And then we get Thio a nine, which is load A.

And actually we see this repeated because really, what's happening here is the transfer excess takes to clock cycles.

So this first clock cycle, where it looks like it's reading a nine from address 8003 That is what happens to be on the bus.

But I think it's still executing the transfer ext.

And it's on this next clock cycle where it's actually reading the load, eh?

Because then it's gonna follow up with Load A F F, which is actually the next instruction.

Then we have a D, which is story, and it's a story six years or two, which is the address for DDR.

Be so this is all just part of the initialization.

So I'm gonna go this pretty quickly just to get to the point where we're actually calling and returning from the subroutine, since I've already shown a lot of this in previous videos.

We'll have Ah, well, this is actually the right.

So it's actually writing the FF to address six years or two, you're gonna read Low Day E zero and then store, eh?

Six years or three, it's now it's gonna store the easy road address six years or three.

Then we have a low day 38 So that's the first instruction that we're actually gonna send to the LCD.

So the next instruction now is going to be the jumps.

A subroutine up code to zero is jumped a subroutine, and then the address of that is going to be 8060 or no, it's not a 060 that this actually kind of fooled me because the 60 it's reading from, you know, address 8010 That is gonna be part of the address that we're jumping to.

But you could see this 80 is actually being read from 101 f f and that is gonna be the bottom of our stack because the FF remember, that is our stack pointer.

And so, actually, what we should be doing is now that we're pointing at that stack, we should be writing Yes, 8011 into the bottom two positions of the stack.

Subtitles ListPlay Video

Subroutine calls, now with RAM — 6502 part 7

straightforward

previous

bit

stack