Hello, new here, and need best recommandations.
Moderator: Moderators
Re: Hello, new here, and need best recommandations.
What exactly is your end goal here? Are you wishing for someone to make a funny cartoon that will somehow teach you 6502 code?
-
- Posts: 205
- Joined: Sun Jun 17, 2018 6:41 pm
Re: Hello, new here, and need best recommandations.
My end goal atm is to master 6502, and make the learning so good, it would or will be impossible to not understand.Sumez wrote:What exactly is your end goal here? Are you wishing for someone to make a funny cartoon that will somehow teach you 6502 code?
The "funny cartoon" is crucial to teach 6502 in young or teen mindset, as that is the most recognized things out there today.
Ever since the Mario Adventure made by DahrkDaiz got me into this homebrew things, I can't tell you how much potential I see in SNES and NES. And I want to make a type of revolution that not even NESMaker can accomplish.
Re: Hello, new here, and need best recommandations.
How old are you, BTW? Just curious.
-
- Posts: 205
- Joined: Sun Jun 17, 2018 6:41 pm
Re: Hello, new here, and need best recommandations.
.............................koitsu wrote:How old are you, BTW? Just curious.
December 16, 1995..........
Re: Hello, new here, and need best recommandations.
Thought I would let you know...I would try to find someone who I hope I can successfully convince, like Shiru, Dahrkdaiz, etc. to tutor me
You are currently talking to people who know as much about 6502 and NES programming as all those people you mentioned.
People like koitsu, memblers, chris covell, etc have been doing this since the 90s.
I don't think Shiru nor Darkdaiz visits any of the forums anymore.
nesdoug.com -- blog/tutorial on programming for the NES
-
- Posts: 205
- Joined: Sun Jun 17, 2018 6:41 pm
Re: Hello, new here, and need best recommandations.
Except the differences is I am absolutely terrible at grammars and specific type of readings. Because private tutors is 99% impossible, I got to explain as much as I can while giving proof that I'm listening and trying. Every tiny details I find, I have to dig it all down the rabbit hole and find ways to make 6502 Assembly teachings look like Kindergarten language programming instead of College programming. Also, I got to find ways and ways to finally get myself to explain correctly. I don't want to be, "Another typical guy who 'forgets' or never progress to help make new tutorials."dougeff wrote:Thought I would let you know...I would try to find someone who I hope I can successfully convince, like Shiru, Dahrkdaiz, etc. to tutor me
You are currently talking to people who know as much about 6502 and NES programming as all those people you mentioned.
People like koitsu, memblers, chris covell, etc have been doing this since the 90s.
I don't think Shiru nor Darkdaiz visits any of the forums anymore.
Re: Hello, new here, and need best recommandations.
There's also a red dot in the top left. But seems like that worked.
Okay. That's what you have to do, to run code in this. You type some there. And click assemble. And click run. If you click Reset it will allow you to run the code again. You don't have to use the example code, or the code I just gave you. You can type your own code in there and see what happens. This will let you see how 6502 behaves. You type instructions in here, and run them. It's that simple.
Underneath the black box (where the white dot appeared) is a debugger. This shows the current "state" of the CPU. The CPU "state" is the current value of all values the CPU can hold. You'll see the familiar A, X, and Y. There's some other values there I won't cover yet. (I know you don't want things introduced before they can properly explained. Those other things are in that set of things.)
Now, I may start covering some things you already know. Please bear with me. The 6502 CPU will run "instructions", one at a time going down. (At least, that's the best way to explain it for now.) The "instruction set" for a CPU is simply all of the things that it can do. 6502 has 56 "instructions". This may seem like a lot, but most of them do something very simple and easy to see.
An instruction is made of a 3 letter code (called a "mnemonic") and sometimes a "something" that follows it. For now, that something will be a number.
Run the code I gave you again, and you'll see this: "A=$01" in the debugger box. Let's talk about why that is. Let's talk about the first "instruction."
LDA stands for LoaD Accumulator. LDA is that 3 letter code we just discussed. The mnemonic.
This will take the value following the instruction, and copy it into the "accumulator". The accumulator is part of the "state" of the CPU.
You can think of the accumulator like a very small box. It can hold exactly one value. To load a new value, the old one has to get removed. So, anytime the CPU gets to an LDA, it will take the old value out of the box, and put the new value specified into the box.
That's really all it does! Remember how "A=$01" in that box after you ran that code? Let's learn how to "step" through code. "Step" means run a single instruction. (Usually this means one line.)
So click "reset". Recheck debugger if you need to. You'll see A=$00. Ignore the rest. Click step once. You'll see "A=$01" in that box. This means it just ran the first line of code.
The first line of code was
And you'll see that after running that line of code, A did indeed get the value $01 put into its box.
Click step again. This will run sta $08. This is a new instruction. This STores the Accumulator to the place specified after the mnemonic. On the 6502 CPU, "Store" is more like a copy, though. The value in the accumulator remains in the accumulator. It's just ALSO copied into the location specified. In this case $08.
Below where the code is (below the monitor checkbox too) you'll see some RAM. RAM is "Random Access Memory". Each location in RAM has a number called its "address". It's not unlike a bunch of post office boxes:
Much like the accumulator (and unlike real post office boxes), each RAM "address" can only hold one value. To put something new in the box, the old thing gets removed.
So, look at location $08. If you start at the top left ($00), and count going right, you'll see that that address ($08) now has the value "$01" in it. It has this value, because that was the value in the accumulator when you told the CPU to store the value in the accumulator into that address.
Click step again. You've already seen one LDA in action. So it should not surprise you that in the CPU "state" the accumulator now has the value $02. But note that address $08 in RAM is still $01. The value is copied FROM the accumulator, but changes to the accumulator don't change that RAM after the copy (or store) has happened.
Click step again. This stores the value in the accumulator (currently 2) into $0200. And while you can't go that far down in the monitor by default, you'll notice the top left part of the black box on the right is now red. On easy6502, storing to addresses $0200 to $05ff will change the colors in that black box. (This is one thing that is ONLY on easy6502. Every thing that uses 6502 has different addresses that have different effects. On NES for instance, storing to $0200-$05FF would not do anything related to graphics.)
So, you see a dark red pixel. The reason that pixel becomes red is simply because $02 means red to it. There's no "why" behind this part. It's just what the designer of easy6502 chose.
Click step again. A now equals $01. Step again. STA $05FF. We've now copied the value in A (currently $01) into the address $05FF. And you recall, that's one of the addresses that changes the pixels in the black box. Remember how $02 meant red? Well, you can probably guess now that $01 means white.
This is how the white dot got there. And now, there's no instructions left. So the code is where it would have been if you had "run" it. (Run runs all the code at once.) So that's why after running, the state of the CPU showed "A=$01". It was the last value placed into A before the program ended.
Let's make two small changes so this is really understood. Remember how $02 is a red pixel and $01 is a white pixel? (In easy6502 only.)
Change
to
and change
to
What happens? Do you understand why what happens DOES happen?
There are a few things I'm glossing over in this post. But does this make sense? If anything and I mean anything does not make sense in this post, ask and I will try to explain it differently. The most important thing is to understand how to run the code a line at a time and understand how to see how each line affects the "state" of the CPU.
Okay. That's what you have to do, to run code in this. You type some there. And click assemble. And click run. If you click Reset it will allow you to run the code again. You don't have to use the example code, or the code I just gave you. You can type your own code in there and see what happens. This will let you see how 6502 behaves. You type instructions in here, and run them. It's that simple.
Underneath the black box (where the white dot appeared) is a debugger. This shows the current "state" of the CPU. The CPU "state" is the current value of all values the CPU can hold. You'll see the familiar A, X, and Y. There's some other values there I won't cover yet. (I know you don't want things introduced before they can properly explained. Those other things are in that set of things.)
Now, I may start covering some things you already know. Please bear with me. The 6502 CPU will run "instructions", one at a time going down. (At least, that's the best way to explain it for now.) The "instruction set" for a CPU is simply all of the things that it can do. 6502 has 56 "instructions". This may seem like a lot, but most of them do something very simple and easy to see.
An instruction is made of a 3 letter code (called a "mnemonic") and sometimes a "something" that follows it. For now, that something will be a number.
Run the code I gave you again, and you'll see this: "A=$01" in the debugger box. Let's talk about why that is. Let's talk about the first "instruction."
LDA stands for LoaD Accumulator. LDA is that 3 letter code we just discussed. The mnemonic.
This will take the value following the instruction, and copy it into the "accumulator". The accumulator is part of the "state" of the CPU.
You can think of the accumulator like a very small box. It can hold exactly one value. To load a new value, the old one has to get removed. So, anytime the CPU gets to an LDA, it will take the old value out of the box, and put the new value specified into the box.
That's really all it does! Remember how "A=$01" in that box after you ran that code? Let's learn how to "step" through code. "Step" means run a single instruction. (Usually this means one line.)
So click "reset". Recheck debugger if you need to. You'll see A=$00. Ignore the rest. Click step once. You'll see "A=$01" in that box. This means it just ran the first line of code.
The first line of code was
Code: Select all
lda #$01
Click step again. This will run sta $08. This is a new instruction. This STores the Accumulator to the place specified after the mnemonic. On the 6502 CPU, "Store" is more like a copy, though. The value in the accumulator remains in the accumulator. It's just ALSO copied into the location specified. In this case $08.
Below where the code is (below the monitor checkbox too) you'll see some RAM. RAM is "Random Access Memory". Each location in RAM has a number called its "address". It's not unlike a bunch of post office boxes:
Much like the accumulator (and unlike real post office boxes), each RAM "address" can only hold one value. To put something new in the box, the old thing gets removed.
So, look at location $08. If you start at the top left ($00), and count going right, you'll see that that address ($08) now has the value "$01" in it. It has this value, because that was the value in the accumulator when you told the CPU to store the value in the accumulator into that address.
Click step again. You've already seen one LDA in action. So it should not surprise you that in the CPU "state" the accumulator now has the value $02. But note that address $08 in RAM is still $01. The value is copied FROM the accumulator, but changes to the accumulator don't change that RAM after the copy (or store) has happened.
Click step again. This stores the value in the accumulator (currently 2) into $0200. And while you can't go that far down in the monitor by default, you'll notice the top left part of the black box on the right is now red. On easy6502, storing to addresses $0200 to $05ff will change the colors in that black box. (This is one thing that is ONLY on easy6502. Every thing that uses 6502 has different addresses that have different effects. On NES for instance, storing to $0200-$05FF would not do anything related to graphics.)
So, you see a dark red pixel. The reason that pixel becomes red is simply because $02 means red to it. There's no "why" behind this part. It's just what the designer of easy6502 chose.
Click step again. A now equals $01. Step again. STA $05FF. We've now copied the value in A (currently $01) into the address $05FF. And you recall, that's one of the addresses that changes the pixels in the black box. Remember how $02 meant red? Well, you can probably guess now that $01 means white.
This is how the white dot got there. And now, there's no instructions left. So the code is where it would have been if you had "run" it. (Run runs all the code at once.) So that's why after running, the state of the CPU showed "A=$01". It was the last value placed into A before the program ended.
Let's make two small changes so this is really understood. Remember how $02 is a red pixel and $01 is a white pixel? (In easy6502 only.)
Change
Code: Select all
lda #$02
sta $0200
Code: Select all
lda #$01
sta $0200
Code: Select all
lda #$01
sta $05FF
Code: Select all
lda #$02
sta $05FF
There are a few things I'm glossing over in this post. But does this make sense? If anything and I mean anything does not make sense in this post, ask and I will try to explain it differently. The most important thing is to understand how to run the code a line at a time and understand how to see how each line affects the "state" of the CPU.
Re: Hello, new here, and need best recommandations.
Cool, 23. Just was curious. Sometimes it helps to know the age of someone wanting assistance; younger folks often require different media and depictions and warrant use of different words when describing something. The 6502 isn't too hard to understand, but some of the NES architecture (particularly PPU behaviour) most certainly is. And FWIW, I can't stand most college textbooks or teaching materials. But everyone learns differently.DocWaluigean wrote:December 16, 1995..........
-
- Posts: 205
- Joined: Sun Jun 17, 2018 6:41 pm
Re: Hello, new here, and need best recommandations.
I'm sorry, but this is honestly hilarious, because I didn't expect this to be this simple explanation with deep examples.Kasumi wrote:There's also a red dot in the top left. But seems like that worked.
Okay. That's what you have to do, to run code in this. You type some there. And click assemble. And click run. If you click Reset it will allow you to run the code again. You don't have to use the example code, or the code I just gave you. You can type your own code in there and see what happens. This will let you see how 6502 behaves. You type instructions in here, and run them. It's that simple.
Underneath the black box (where the white dot appeared) is a debugger. This shows the current "state" of the CPU. The CPU "state" is the current value of all values the CPU can hold. You'll see the familiar A, X, and Y. There's some other values there I won't cover yet. (I know you don't want things introduced before they can properly explained. Those other things are in that set of things.)
Now, I may start covering some things you already know. Please bear with me. The 6502 CPU will run "instructions", one at a time going down. (At least, that's the best way to explain it for now.) The "instruction set" for a CPU is simply all of the things that it can do. 6502 has 56 "instructions". This may seem like a lot, but most of them do something very simple and easy to see.
An instruction is made of a 3 letter code (called a "mnemonic") and sometimes a "something" that follows it. For now, that something will be a number.
Run the code I gave you again, and you'll see this: "A=$01" in the debugger box. Let's talk about why that is. Let's talk about the first "instruction."
LDA stands for LoaD Accumulator. LDA is that 3 letter code we just discussed. The mnemonic.
This will take the value following the instruction, and copy it into the "accumulator". The accumulator is part of the "state" of the CPU.
You can think of the accumulator like a very small box. It can hold exactly one value. To load a new value, the old one has to get removed. So, anytime the CPU gets to an LDA, it will take the old value out of the box, and put the new value specified into the box.
That's really all it does! Remember how "A=$01" in that box after you ran that code? Let's learn how to "step" through code. "Step" means run a single instruction. (Usually this means one line.)
So click "reset". Recheck debugger if you need to. You'll see A=$00. Ignore the rest. Click step once. You'll see "A=$01" in that box. This means it just ran the first line of code.
The first line of code wasAnd you'll see that after running that line of code, A did indeed get the value $01 put into its box.Code: Select all
lda #$01
Click step again. This will run sta $08. This is a new instruction. This STores the Accumulator to the place specified after the mnemonic. On the 6502 CPU, "Store" is more like a copy, though. The value in the accumulator remains in the accumulator. It's just ALSO copied into the location specified. In this case $08.
Below where the code is (below the monitor checkbox too) you'll see some RAM. RAM is "Random Access Memory". Each location in RAM has a number called its "address". It's not unlike a bunch of post office boxes:
Much like the accumulator (and unlike real post office boxes), each RAM "address" can only hold one value. To put something new in the box, the old thing gets removed.
So, look at location $08. If you start at the top left ($00), and count going right, you'll see that that address ($08) now has the value "$01" in it. It has this value, because that was the value in the accumulator when you told the CPU to store the value in the accumulator into that address.
Click step again. You've already seen one LDA in action. So it should not surprise you that in the CPU "state" the accumulator now has the value $02. But note that address $08 in RAM is still $01. The value is copied FROM the accumulator, but changes to the accumulator don't change that RAM after the copy (or store) has happened.
Click step again. This stores the value in the accumulator (currently 2) into $0200. And while you can't go that far down in the monitor by default, you'll notice the top left part of the black box on the right is now red. On easy6502, storing to addresses $0200 to $05ff will change the colors in that black box. (This is one thing that is ONLY on easy6502. Every thing that uses 6502 has different addresses that have different effects. On NES for instance, storing to $0200-$05FF would not do anything related to graphics.)
So, you see a dark red pixel. The reason that pixel becomes red is simply because $02 means red to it. There's no "why" behind this part. It's just what the designer of easy6502 chose.
Click step again. A now equals $01. Step again. STA $05FF. We've now copied the value in A (currently $01) into the address $05FF. And you recall, that's one of the addresses that changes the pixels in the black box. Remember how $02 meant red? Well, you can probably guess now that $01 means white.
This is how the white dot got there. And now, there's no instructions left. So the code is where it would have been if you had "run" it. (Run runs all the code at once.) So that's why after running, the state of the CPU showed "A=$01". It was the last value placed into A before the program ended.
Let's make two small changes so this is really understood. Remember how $02 is a red pixel and $01 is a white pixel? (In easy6502 only.)
ChangetoCode: Select all
lda #$02 sta $0200
and changeCode: Select all
lda #$01 sta $0200
toCode: Select all
lda #$01 sta $05FF
What happens? Do you understand why what happens DOES happen?Code: Select all
lda #$02 sta $05FF
There are a few things I'm glossing over in this post. But does this make sense? If anything and I mean anything does not make sense in this post, ask and I will try to explain it differently. The most important thing is to understand how to run the code a line at a time and understand how to see how each line affects the "state" of the CPU.
I tried it again on first one, and I did see the red dot on other side of white dot.
I know that instructions is opcode ; operation code?
I also know what mnemonic means, but I can't provide descriptions on what it really means without dictionary.
Is "something" an address code? Real Number?
Alright, I got lost on the "So click "reset". Recheck debugger if you need to." because it feels like it's starting to lose certain information.
-"A did indeed get the value $01 put into it's box" ???And you'll see that after running that line of code, A did indeed get the value $01 put into its box.
Click step again. This will run sta $08. This is a new instruction. This STores the Accumulator to the place specified after the mnemonic. On the 6502 CPU, "Store" is more like a copy, though. The value in the accumulator remains in the accumulator. It's just ALSO copied into the location specified. In this case $08.
"A got the value / Address $01 into "the box that's written 'A'"?
-I thought you can't change the RAM styles? or was it that you can't save it?
I honestly really enjoy this effort though.
-
- Posts: 205
- Joined: Sun Jun 17, 2018 6:41 pm
Re: Hello, new here, and need best recommandations.
It's not just college materials. It's that 90% of "teachers" just doesn't care about the "gift" side of every student like Elementary / Middle / High school teacher did. You have to pay approximately 300$ - 500$ just to take one class. It was real bad, one of the tutors for "Special Disability / Study Center" gave me a C / C++ book to keep and said that the materials is too hard, and I have to put so much effort. The only reason I pass as B is because I had to stay after school starting week 3. It's one of last Colleges before I lost respect for them.koitsu wrote:Cool, 23. Just was curious. Sometimes it helps to know the age of someone wanting assistance; younger folks often require different media and depictions and warrant use of different words when describing something. The 6502 isn't too hard to understand, but some of the NES architecture (particularly PPU behaviour) most certainly is. And FWIW, I can't stand most college textbooks or teaching materials. But everyone learns differently.DocWaluigean wrote:December 16, 1995..........
As I agree on what you said that everyone learns differently, I feel as though showing an age of adult is sign of shame or dishonor..
Re: Hello, new here, and need best recommandations.
Let's start with where you actually got stuck, since a few other answers you want might be a bit better understood after you get unstuck.
So for that section starting from the total beginning (refresh the page), you want this code again (from the previous post, sorry, yes, that wasn't clear):
Remove any code already in the box. Paste the code above into the box. Click Assemble, check "Debugger", and check "Monitor". And then continue reading the post.
I'll answer your questions in a different order than you asked, because they sort of flow into each other. And it's okay to not understand these things too! So long as you get to the end of that other post, I promise you're getting somewhere.
The "something" is the "addressing mode". (Edit: Kasumi learned something new today! I guess it's really called the "operand", but addressing modes are still pretty important to learn so let's go!) And it's often an address or a real number. Most instructions have several "addressing modes". And usually the addressing mode affects which value is used, but not... the "goal" of the instruction? (Goal here is not a technical term.) For example, LDA always copies some value into the accumulator. That's its goal. The addressing mode affects how the value that gets copied is fetched.
For example #$XX (where XX is any one hexadecimal value between $00 and $FF) is called "immediate" addressing. (You don't really need to remember the names of the addressing modes.) A number symbol '#' before a value means immediate addressing. Immediate addressing means use that value given as it is. If you leave out the number symbol, it's a different addressing mode. (And you will definitely mess them up accidentally at least once in your code! It's a rite of passage. )
lda #$00 means A (the accumulator) will get the value $00.
lda #$FF means A will get the value $FF.
Immediate is the easiest addressing mode.
Two other addressing modes are used in the post.
$XX (where XX is any value between $00 and $FF) is "zero page" addressing. $0000-$00FF in RAM are called the zero page because their leftmost digits are, well, zero. Rather than use the value of "XX" directly, it uses the value stored in RAM at $00XX.
lda $00 means A will get the value stored at $0000.
lda $08 means A will get the value stored at $0008.
$XXXX is "absolute" addressing.
lda $0200 means A will get the value stored at $0200. It's worth noting there's no guarantee an "absolute" address is RAM. What's RAM and what influences hardware is one of the things that can change between things that use 6502.
If you don't understand addressing modes, please, please don't get hung up on it. They're... eventually necessarily knowledge, but they become easier to understand once you start coding a bit.
Shorter, the opcode is the byte that tells the CPU exactly what to do.
What the CPU does, is read a byte (the opcode), do the action associated with that byte (run the instruction, which may involve reading a few more bytes). When that instruction is done, it will read another byte, and do the action associated with that byte. Basically forever.
Again, if that doesn't make much sense, don't worry too much. You can actually get away with never learning much about opcodes.
"Reset" (next to "Run" and "Hexdump"), takes the CPU back to its initial "state". "Recheck debugger" means Check the checkbox next to the "Debugger" option. (Underneath the black box.) You have to check "Debugger" again after you click "Run". Which... is a bit annoying, but hey, it's still a good package.Alright, I got lost on the "So click "reset". Recheck debugger if you need to." because it feels like it's starting to lose certain information.
So for that section starting from the total beginning (refresh the page), you want this code again (from the previous post, sorry, yes, that wasn't clear):
Code: Select all
lda #$01
sta $08
lda #$02
sta $0200
lda #$01
sta $05FF
I described earlier in the post that A (the accumulator) was like a box that holds one value. So this put the value $01 into that box. (That is, that A now hold the value $01.) Does this make sense now?-"A did indeed get the value $01 put into it's box" ???
I'll answer your questions in a different order than you asked, because they sort of flow into each other. And it's okay to not understand these things too! So long as you get to the end of that other post, I promise you're getting somewhere.
This one's tough... I want to say maybe wait for the answer, but I'll try to get the basics.Is "something" an address code? Real Number?
The "something" is the "addressing mode". (Edit: Kasumi learned something new today! I guess it's really called the "operand", but addressing modes are still pretty important to learn so let's go!) And it's often an address or a real number. Most instructions have several "addressing modes". And usually the addressing mode affects which value is used, but not... the "goal" of the instruction? (Goal here is not a technical term.) For example, LDA always copies some value into the accumulator. That's its goal. The addressing mode affects how the value that gets copied is fetched.
For example #$XX (where XX is any one hexadecimal value between $00 and $FF) is called "immediate" addressing. (You don't really need to remember the names of the addressing modes.) A number symbol '#' before a value means immediate addressing. Immediate addressing means use that value given as it is. If you leave out the number symbol, it's a different addressing mode. (And you will definitely mess them up accidentally at least once in your code! It's a rite of passage. )
lda #$00 means A (the accumulator) will get the value $00.
lda #$FF means A will get the value $FF.
Immediate is the easiest addressing mode.
Two other addressing modes are used in the post.
$XX (where XX is any value between $00 and $FF) is "zero page" addressing. $0000-$00FF in RAM are called the zero page because their leftmost digits are, well, zero. Rather than use the value of "XX" directly, it uses the value stored in RAM at $00XX.
lda $00 means A will get the value stored at $0000.
lda $08 means A will get the value stored at $0008.
$XXXX is "absolute" addressing.
lda $0200 means A will get the value stored at $0200. It's worth noting there's no guarantee an "absolute" address is RAM. What's RAM and what influences hardware is one of the things that can change between things that use 6502.
If you don't understand addressing modes, please, please don't get hung up on it. They're... eventually necessarily knowledge, but they become easier to understand once you start coding a bit.
Opcode is operation code, yes. Each mnemonic can have several "opcodes". And the reason for this is because of the addressing modes. LDA #$00 has a different "opcode" than LDA $00. (The different opcode is how the CPU fetches the right value to put in the accumulator.)I know that instructions is opcode ; operation code?
Shorter, the opcode is the byte that tells the CPU exactly what to do.
What the CPU does, is read a byte (the opcode), do the action associated with that byte (run the instruction, which may involve reading a few more bytes). When that instruction is done, it will read another byte, and do the action associated with that byte. Basically forever.
Again, if that doesn't make much sense, don't worry too much. You can actually get away with never learning much about opcodes.
I don't understand what you mean by RAM styles. Can you rephrase the question?-I thought you can't change the RAM styles? or was it that you can't save it?
-
- Posts: 205
- Joined: Sun Jun 17, 2018 6:41 pm
Re: Hello, new here, and need best recommandations.
So the Debugger and Monitor ALWAYS need to be turn on?Kasumi wrote:Let's start with where you actually got stuck, since a few other answers you want might be a bit better understood after you get unstuck."Reset" (next to "Run" and "Hexdump"), takes the CPU back to its initial "state". "Recheck debugger" means Check the checkbox next to the "Debugger" option. (Underneath the black box.) You have to check "Debugger" again after you click "Run". Which... is a bit annoying, but hey, it's still a good package.Alright, I got lost on the "So click "reset". Recheck debugger if you need to." because it feels like it's starting to lose certain information.
So for that section starting from the total beginning (refresh the page), you want this code again (from the previous post, sorry, yes, that wasn't clear):Remove any code already in the box. Paste the code above into the box. Click Assemble, check "Debugger", and check "Monitor". And then continue reading the post.Code: Select all
lda #$01 sta $08 lda #$02 sta $0200 lda #$01 sta $05FF
I described earlier in the post that A (the accumulator) was like a box that holds one value. So this put the value $01 into that box. (That is, that A now hold the value $01.) Does this make sense now?-"A did indeed get the value $01 put into it's box" ???
I'll answer your questions in a different order than you asked, because they sort of flow into each other. And it's okay to not understand these things too! So long as you get to the end of that other post, I promise you're getting somewhere.This one's tough... I want to say maybe wait for the answer, but I'll try to get the basics.Is "something" an address code? Real Number?
The "something" is the "addressing mode". (Edit: Kasumi learned something new today! I guess it's really called the "operand", but addressing modes are still pretty important to learn so let's go!) And it's often an address or a real number. Most instructions have several "addressing modes". And usually the addressing mode affects which value is used, but not... the "goal" of the instruction? (Goal here is not a technical term.) For example, LDA always copies some value into the accumulator. That's its goal. The addressing mode affects how the value that gets copied is fetched.
For example #$XX (where XX is any one hexadecimal value between $00 and $FF) is called "immediate" addressing. (You don't really need to remember the names of the addressing modes.) A number symbol '#' before a value means immediate addressing. Immediate addressing means use that value given as it is. If you leave out the number symbol, it's a different addressing mode. (And you will definitely mess them up accidentally at least once in your code! It's a rite of passage. )
lda #$00 means A (the accumulator) will get the value $00.
lda #$FF means A will get the value $FF.
Immediate is the easiest addressing mode.
Two other addressing modes are used in the post.
$XX (where XX is any value between $00 and $FF) is "zero page" addressing. $0000-$00FF in RAM are called the zero page because their leftmost digits are, well, zero. Rather than use the value of "XX" directly, it uses the value stored in RAM at $00XX.
lda $00 means A will get the value stored at $0000.
lda $08 means A will get the value stored at $0008.
$XXXX is "absolute" addressing.
lda $0200 means A will get the value stored at $0200. It's worth noting there's no guarantee an "absolute" address is RAM. What's RAM and what influences hardware is one of the things that can change between things that use 6502.
If you don't understand addressing modes, please, please don't get hung up on it. They're... eventually necessarily knowledge, but they become easier to understand once you start coding a bit.Opcode is operation code, yes. Each mnemonic can have several "opcodes". And the reason for this is because of the addressing modes. LDA #$00 has a different "opcode" than LDA $00. (The different opcode is how the CPU fetches the right value to put in the accumulator.)I know that instructions is opcode ; operation code?
Shorter, the opcode is the byte that tells the CPU exactly what to do.
What the CPU does, is read a byte (the opcode), do the action associated with that byte (run the instruction, which may involve reading a few more bytes). When that instruction is done, it will read another byte, and do the action associated with that byte. Basically forever.
Again, if that doesn't make much sense, don't worry too much. You can actually get away with never learning much about opcodes.I don't understand what you mean by RAM styles. Can you rephrase the question?-I thought you can't change the RAM styles? or was it that you can't save it?
I'm guessing A ~=~ $01. The pseudocode, " ~=~ " is "is now carrying..."
[It's getting late and need to sleep. I REALLY hope I learn something as I wake up. You can make edits or replies if you want!]
Re: Hello, new here, and need best recommandations.
You probably always want them on while learning, yes. The debugger is what you lets run a single instruction, which is helpful for seeing the exact result of that instruction.So the Debugger and Monitor ALWAYS need to be turn on?
The monitor lets you view RAM, but it's much more willing to stay "on" than the debugger.
Code: Select all
I'm guessing A ~=~ $01. The pseudocode, " ~=~ " is "is now carrying..."
-
- Posts: 1565
- Joined: Tue Feb 07, 2017 2:03 am
Re: Hello, new here, and need best recommandations.
Sorry I've not really been tracking this topic..
How to learn programming with funny comics, and easy to read follow along. This does exist, just it was all done before your time...
https://usborne.com/browse-books/featur ... ing-books/ scroll past the modern crap python stuff and you will get down to the free pfds. SO Programming Tricks and Skills, Machine Code programming for beginners, Basic for beginners, Computer battlegames etc Are great for learning. I read them when I was 6 and first got my Commodore 64. They have diagrams with robot and make puns etc.
From there http://www.bombjack.org/commodore/books.htm
Machine Language
on the Commodore 64, 128 and other Commodore Computers Revised and Expanded Edition by Jim Butterfield is the book to learn from, Jim was a celebrity back in the late 70s and was "the expert" on 6502 and Commodore computers. The Compute's guide too books are also very nice introductions.
The Abacus books are a bit higher level, more of a professional of the era teaching guide.
Commodore 64 Assembly Language by Bruce Smith is in the middle. But if you have a book and the style or language doesn't work for you, just pick another one.
Or hit up Archive.org and read the old Compute magazines, or Your Commodore etc from back when the Commodore, Atari and Apple computers where the hottest thing on the market.
How to learn programming with funny comics, and easy to read follow along. This does exist, just it was all done before your time...
https://usborne.com/browse-books/featur ... ing-books/ scroll past the modern crap python stuff and you will get down to the free pfds. SO Programming Tricks and Skills, Machine Code programming for beginners, Basic for beginners, Computer battlegames etc Are great for learning. I read them when I was 6 and first got my Commodore 64. They have diagrams with robot and make puns etc.
From there http://www.bombjack.org/commodore/books.htm
Machine Language
on the Commodore 64, 128 and other Commodore Computers Revised and Expanded Edition by Jim Butterfield is the book to learn from, Jim was a celebrity back in the late 70s and was "the expert" on 6502 and Commodore computers. The Compute's guide too books are also very nice introductions.
The Abacus books are a bit higher level, more of a professional of the era teaching guide.
Commodore 64 Assembly Language by Bruce Smith is in the middle. But if you have a book and the style or language doesn't work for you, just pick another one.
Or hit up Archive.org and read the old Compute magazines, or Your Commodore etc from back when the Commodore, Atari and Apple computers where the hottest thing on the market.
-
- Posts: 1318
- Joined: Thu Apr 23, 2009 11:21 pm
- Location: cypress, texas
Re: Hello, new here, and need best recommandations.
DocWaluigean, I know that this post of mine didn't make much sense to you when you read it; but, I want you to know that rereading lots of my thread was extremely helpful to me and most of the posts that I didn't fully understand made tons more sense to me after I got more comfortable with 6502. My post I linked describes, to the best of my ability, the most crucial assembly information I learned in college; I hope you'll revisit it after you get more comfortable with 6502. Knowing that has made me more comfortable with 6502 because I know what's really happening at the 6502 "foundation".
p.s. Here is booker's excellent post office RAM/ROM explanation to me. Kasumi's post office picture reminded me of booker's post.
edit: fixed spelling of "extreemly" and added an "s" to the http in my second link. Sorry.
p.s. Here is booker's excellent post office RAM/ROM explanation to me. Kasumi's post office picture reminded me of booker's post.
edit: fixed spelling of "extreemly" and added an "s" to the http in my second link. Sorry.