and it's usually a pretty simple starting point because the programming language in this case Python and everything gets built on top of

Does a lot of the work but what if we don't have any of that what if we just start with a microprocessor?

And how do we get from this to printing HelloWorld on a screen of some sort?

Well, this is the 6502 microprocessor and it's a real classic

You can see from the date code that this one was manufactured in the third week of 1989

but the design for this has been around since

1975 and versions of this chip found their way into many personal computers and game consoles in the 80s

But believe it or not

Even though the original design is 44 years old a version of the 6502 is still being manufactured today

And in fact for reasons, I'll get into later. I'm gonna use this modern version

and so here it is and here's the datasheet Ford and you can see the data sheets only about 30 pages long, but well

Let's start take a look at the pinout for this and start hooking up some of these pins to see what we can get it

To do you can see there's a description here as well

For what each of the pins are and if we flip back a couple pages

You can see a more detailed description of each of the pins and exactly what the function is

But let's start with the power pin. So VDD is positive power VSS is the ground

so I'll put the microprocessor on a breadboard here and

VDD is pin eight and that's our positive power supply

So I'll connect that to the positive power rail of our breadboard and then VSS is pin 21, so that's ground

So I'll connect that to the ground rail on the breadboard

So at this point if we connected five volts here to our breadboard it would power up the microprocessor

but it's not gonna do very much because we need to connect some of these other pins and if we look at these pins you

Know some are going to be inputs and some are going to be outputs and the outputs

I'm not gonna worry about too much just yet. Yes, for example

Pin 1 here is vector pol and we can see here that is an output and it indicates, you know some particular condition

But if we don't care about what it's outputting then we don't need to connect it to anything to get the processor to work

Yeah, but that's not the case for pin 2 your pin 2 is the ready pin and that's it

And you can see that's an input and so it is going to matter to the processor what we hook this to and in fact

the ready signal indicates

so whether the processor is going to run or orbit or halt and

So if we want it to run we need to hook pin 2 to 5 volts

It's now I'm basically going to do same thing for the rest of these pins, you know any pins that are inputs

I want to hook to something reasonable. That'll get the microprocessor to run and so I'll just go pin by pin

So pin three here five 100. That's an output

So I'm not gonna worry about that

Pin four is the IR QB that's interrupt request and that that's an input and bringing it low will trigger an interrupt

So I'll just high it high for now so that we're not triggering an interrupt

Pin five MLB that's a memory lock. That's another output. So I'll leave that alone and it might be that's the non-maskable interrupt

So just like the regular interrupt request here

Bringing it low triggers the non-maskable interrupt. So I'll tie that high as well

So we're not triggering that sync is another output. So we'll connect that to anything yet VDD, of course. We already have that connected

that's our positive power supply and then we have this a zero all the way around through a

15 and these are the sixteen address lines and so they're actually all outputs

So I'll leave them unconnected for now as well in the mix. We have these these eight pins here d0 through d7

That's the the data bus and these can actually be inputs or outputs

and in fact the next pin here this rwb pin 34

That's an output signal that tells us whether the processor is using the data pins for input or for output

So this read/write signal and on pin 44 34 if that's high then that means the data bus pins are inputs

And if that's low then it means the data bus pins are our outputs

So for now I'm going to leave these unconnected, but we will need to come back here and connect something to these

So moving on NC is no connect. So that means we actually shouldn't connect anything to that. So that's easy

In 36b II that's bus enable and that's another input

so the bus enable signal needs to be high in order for the processor to put anything out on either the address bus or the

Data bus. So basically we want that to be high all the time. So I'll connect pin 36 to 5 volts

So it's high and then we get to pin 37 is phi2 and that's the clock input and you know

Like all computers. We need a system clock in order to provide timing toward the microprocessor and

You know the original 6502 used a 1 megahertz clock

But this modern version that I'm using is a bit more flexible so we can actually run it up to 17 megahertz

You know an easy way to provide a clock input is to use one of these crystal oscillator modules, you know

This one for example is 10 megahertz

And so if we just connected ground and 5 volts here

It would output a 10 megahertz clock that could then just connect directly to pin 37 up here

But in this video, I actually want to run the clock much slower so we can really see what's going on

So I'm not going to use this instead

I'm going to use this clock module that I built in some previous videos for for my other breadboard CPU project and

If I power this up you can see us it gives us a clock pulse that we can actually adjust

So I can slow it down

or speed it up and and we can also halt it and

Then single-step it so we can get nice single clean clock pulses that way

And if you want to know more about how this works, you know

I've got several videos that walk through it all and

explain how the the five five five timer that we're using works in a stable monostable and by stable modes, so

You know check that out there

If you're if you're interested there in any event, I'll connect this clock here to pin 37

which is our clock input over here and

Let that clock run and this is where it's actually really important that I'm using the modern static version of the 6502

Because the datasheet here says that phi2 can be held in either the high or low state and it'll preserve the contents of internal registers

And that's actually not the case with the original 6502

If the clock for this stopped or got too slow, it just wouldn't work

You'd lose the contents of the internal registers

But but here because we're using this this modern the W 65 c02 which is a fully static design

We can stop the clock and we can single-step it which is which is really nice

and so that's the clock pin 37 and so just for the last couple of pins pin 38 is set overflow and

that that's an input but the datasheet basically says it's not recommended to do anything with it other than just high and high so so

that's what I'll do and

Then pin 39 5 - oh, that's an output

So we won't do anything with that and then pin 40 is the reset signal which normally needs to be tied high when the processor

Is running but will want to be able to bring it low to reset the processor

So what I'll do is I'll tie it high through a 1k resistor

So now it's tied to 5 volts through that 1k resistor

But then what I'll do is I'll add a button here and then I'll connect the other side of the button to ground that way

When we push the button that will short this pin to ground and and and trigger a reset

Otherwise if we're not pushing the button it won't be shorted to ground and it will be tied to 5 volts through that resistor

And so that ought to take care of pretty much everything

We need to set up just to get the processor to do something. And so I've connected power across here

So if we just plug in five volts over here, then that should power up everything and of course

We've got the clock running. So we hit the reset button here. That should reset the microprocessor

And now the processor is is maybe doing something

But but what is it doing? How can we figure out what's going on here?

Well, you know, of course

We still have a bunch of output pins here that we haven't hooked anything yet

So we could hook up some of those output pins, you know to drive some LEDs and see if they're doing anything

So let's give that a try

I'll add a couple LEDs here that we can use to look at some of the outputs from the microprocessor and

Then I'll connect a few of the address lines to them

And so I'm just connecting up the first five address lines a zero through a four

And then I'll connect the other side of the LEDs to ground through 220. Ohm resistors and okay, so

something's going on here, you know the process is doing something but you know, I'm not really entirely sure what so

How can we get a better picture of what's going on here?

you know well

We could certainly add a bunch more LEDs to look at the rest of the address lines and maybe look at some of the data

lines and maybe some of these other output signals, but you know

That's that's a lot of LEDs and it's gonna be really hard to keep track of everything going on, you know

Especially if we're trying to sort of figure out kind of a pattern over over a period of time

Yeah, but there are tools we can use to make analyzing a digital circuit like this easier

So, for example, we could use a logic analyzer which has a whole bunch of inputs

and you know

the one I've got has 16 inputs here and we can hook each of these inputs up to a separate signal and

use the logic analyzer to capture what's going on over a period of time so we can analyze it and

Then if we capture while the circuit is running what we get is a display like this that tracks each of the signals

So here we can see all of our address lines and you know, maybe you try to figure out from this, you know

What's going on?

And so logic analyzer is great, especially for a high-speed circuit with a lot going on

But for something lower speed like this that we can actually run and we in fact want to run pretty slow

Yeah, I think a logic analyzers is overkill, you know

I think I'm much better and definitely less expensive tool is actually just in Arduino

because if we want to monitor what these address lines are doing

we could just hook them up to inputs on the Arduino and have the Arduino just read whatever is on each of these pins and

You know, especially something like this Arduino mega. It's got, you know, something like 50 digital inputs

So way more than the 16 inputs that we have on

Nice logic analyzer like this the drawback, of course is you know, the Arduino is much slower, you know

We can read millions of samples per second with a logic analyzer. But that's fine, you know for running our clocks slow enough

That's that's not going to be a big deal

So forget the logic analyzer out of the way and also get these LEDs out of here

Then what I can do is hook those 16 address lines up to 16 of the digital i/o pins on this Arduino, you know

So just like the logic analyzer the Arduino can then keep track of you know, what each address line is doing

so I'll connect this ribbon cable with 16 connectors over to 16 of the digital inputs on the Arduino and

On the other end. I'll connect to the 16 address lines

And also need to connect the ground

Of course and so once I've got the 16 address lines then connected into 16 digital i/o pins of the Arduino

I don't need to program the Arduino to read each other's address lines and show us what it's doing

Okay

So I'll start by listing out the 16 pin numbers that I used and I guess I could use any of the digital i/o pins

on the Arduino

But these are the 16 pins that I used for the address

Starting with a 15 which is on pin 22

And going to a 0 which is on pin 52 at the bottom then in the setup function. I'll loop through all 16 pins and

Set the pin mode for each 2

Input and so what that does is just sets all 16 of these pin numbers here

It just it just goes through all 16 of them and sets them to input and then in the loop function here

I want to I want to go through each of those same pins again

And here I want to actually read each bit. I

think digital read returns a boolean

So if I want a 1 or a 0 here and I can say if it's true, I want a 1

otherwise I want to 0 and

then what I can do is I can assign this to an integer and then after we have that 0 or 1 we can we

Can print that to the serial monitor?

Then after we've printed all 16 bits here, then we'll print a new line. So this ought to read all 16 bits

From from pin 22 which is which is address 15 all the way down to address 0 and print each bit in order

And then print a new line. It'll just keep doing that

And of course in our setup, we need to initialize the serial port up here. So we'll initialize the serial port to

57600 which is just a standard speed. Okay. So this oughta continually read those 16 bits and print them on the serial

So let's give it a try. I'll connect the Arduino up and then compile and upload the sketch

There we go now if I open up the serial monitor

Hey we are seeing

Or saying some numbers and so it looks like we're getting what we're getting something. But how do we make sense of this?

You know, it looks like it's just kind of spewing a bunch of ones and zeros that are changing, you know