Previous Week - NES architecture overview

This Week: starts getting into more details about the 6502 and intro to assembly language. The lessons for asm usage and NES specifics will be done in sections together. There are many other 6502 websites and good books which may help you learn better.



6502 Assembly
Bit - The smallest unit in computers. It is either a 1 (on) or a 0 (off), like a light switch.

Byte - 8 bits together form one byte, a number from 0 to 255. Two bytes put together is 16 bits, forming a number from 0 to 65535. Bits in the byte are numbered starting from the right at 0.

Instruction - one command a processor executes. Instructions are run sequentially.

Code Layout
In assembly language there are 5 main parts. Some parts must be in a specific horizontal position for the assembler to use them correctly.

Directives
Directives are commands you send to the assembler to do things like locating code in memory. They start with a . and are indented. Some people use tabs, or 4 spaces, and I use 2 spaces. This sample directive tells the assembler to put the code starting at memory location $8000, which is inside the game ROM area:

  .org $8000

Labels
The label is aligned to the far left and has a : at the end. The label is just something you use to organize your code and make it easier to read. The assembler translates the label into an address. Sample label:

  .org $8000
MyFunction:

When the assembler runs, it will do a find/replace to set MyFunction to $8000. The if you have any code that uses MyFunction like:

  STA MyFunction

It will find/replace to:

  STA $8000

Opcodes
The opcode is the instruction that the processor will run, and is indented like the directives. In this sample, JMP is the opcode that tells the processor to jump to the MyFunction label:

  .org $8000
MyFunction:
  JMP MyFunction

Operands
The operands are additional information for the opcode. Opcodes have between one and three operands. In this example the #$FF is the operand:

  .org $8000
MyFunction:
  LDA #$FF
  JMP MyFunction

Comments
Comments are to help you understand in English what the code is doing. When you write code and come back later, the comments will save you. You do not need a comment on every line, but should have enough to explain what is happening. Comments start with a ; and are completely ignored by the assembler. They can be put anywhere horizontally, but are usually spaced beyond the long lines.

  .org $8000
MyFunction:        ; loads FF into accumulator
  LDA #$FF
  JMP MyFunction

This code would just continually run the loop, loading the hex value $FF into the accumulator each time.



6502 Processor Overview
The 6502 is an 8 bit processor with a 16 bit address bus. It can access 64KB of memory without bank switching. In the NES this memory space is split up into RAM, PPU/Audio/Controller access, and game ROM.

$0000-0800 - Internal RAM, 2KB chip in the NES
$2000-2007 - PPU access ports
$4000-4017 - Audio and controller access ports
$6000-7FFF - Optional WRAM inside the game cart
$8000-FFFF - Game cart ROM

Any of the game cart sections can be bank switched to get access to more memory, but memory mappers will not be included in this tutorial.



6502 Assembly Overview
The assembly language for 6502 starts with a 3 character code for the instruction "opcode". There are 56 instructions, 10 of which you will use frequently. Many instructions will have a value after the opcode, which you can write in decimal or hex. If that value starts with a # then it means use the actual number. If the value doesn't have then # then it means use the value at that address. So LDA #$05 means load the value 5, LDA $0005 means load the value that is stored at address $0005.



6502 Registers
A register is a place inside the processor that holds a value. The 6502 has three 8 bit registers and a status register that you will be using. All your data processing uses these registers. There are additional registers that are not covered in this tutorial.

Accumulator
The Accumulator (A) is the main 8 bit register for loading, storing, comparing, and doing math on data. Some of the most frequent operations are:

LDA #$FF  ;load the hex value $FF (decimal 256) into A
STA $0000 ;store the accumulator into memory location $0000, internal RAM

Index Register X
The Index Register X (X) is another 8 bit register, usually used for counting or memory access. In loops you will use this register to keep track of how many times the loop has gone, while using A to process data. Some frequent operations are:

LDX $0000 ;load the value at memory location $0000 into X
INX       ;increment X   X = X + 1

Index Register Y
The Index Register Y (Y) works almost the same as X. Some instructions (not covered here) only work with X and not Y. Some operations are:

STY $00BA ;store Y into memory location $00BA
TYA       ;transfer Y into Accumulator

Status Register
The Status Register holds flags with information about the last instruction. For example when doing a subtract you can check if the result was a zero.



6502 Instruction Set
These are just the most common and basic instructions. Most have a few different options which will be used later. There are also a few more complicated instructions to be covered later.

Common Load/Store opcodes

LDA #$0A   ; LoaD the value 0A into the accumulator A
           ; the number part of the opcode can be a value or an address
           ; if the value is zero, the zero flag will be set.

LDX $0000  ; LoaD the value at address $0000 into the index register X
           ; if the value is zero, the zero flag will be set.

LDY #$FF   ; LoaD the value $FF into the index register Y
           ; if the value is zero, the zero flag will be set.

STA $2000  ; STore the value from accumulator A into the address $2000
           ; the number part must be an address

STX $4016  ; STore value in X into $4016
           ; the number part must be an address

STY $0101  ; STore Y into $0101
           ; the number part must be an address

TAX        ; Transfer the value from A into X
           ; if the value is zero, the zero flag will be set

TAY        ; Transfer A into Y
           ; if the value is zero, the zero flag will be set

TXA        ; Transfer X into A
           ; if the value is zero, the zero flag will be set

TYA        ; Transfer Y into A
           ; if the value is zero, the zero flag will be set

Common Math opcodes

ADC #$01   ; ADd with Carry
           ; A = A + $01 + carry
           ; if the result is zero, the zero flag will be set

SBC #$80   ; SuBtract with Carry
           ; A = A - $80 - (1 - carry)
           ; if the result is zero, the zero flag will be set

CLC        ; CLear Carry flag in status register
           ; usually this should be done before ADC

SEC        ; SEt Carry flag in status register
           ; usually this should be done before SBC

INC $0100  ; INCrement value at address $0100
           ; if the result is zero, the zero flag will be set

DEC $0001  ; DECrement $0001
           ; if the result is zero, the zero flag will be set

INY        ; INcrement Y register
           ; if the result is zero, the zero flag will be set

INX        ; INcrement X register
           ; if the result is zero, the zero flag will be set

DEY        ; DEcrement Y
           ; if the result is zero, the zero flag will be set

DEX        ; DEcrement X
           ; if the result is zero, the zero flag will be set

ASL A      ; Arithmetic Shift Left
           ; shift all bits one position to the left
           ; this is a multiply by 2
           ; if the result is zero, the zero flag will be set

LSR $6000  ; Logical Shift Right
           ; shift all bits one position to the right
           ; this is a divide by 2
           ; if the result is zero, the zero flag will be set

Common Comparison opcodes

CMP #$01   ; CoMPare A to the value $01
           ; this actually does a subtract, but does not keep the result
           ; instead you check the status register to check for equal, 
           ; less than, or greater than

CPX $0050  ; ComPare X to the value at address $0050

CPY #$FF   ; ComPare Y to the value $FF

Common Control Flow opcodes

JMP $8000  ; JuMP to $8000, continue running code there

BEQ $FF00  ; Branch if EQual, contnue running code there
           ; first you would do a CMP, which clears or sets the zero flag
           ; then the BEQ will check the zero flag
           ; if zero is set (values were equal) the code jumps to $FF00 and runs there
           ; if zero is clear (values not equal) there is no jump, runs next instruction

BNE $FF00  ; Branch if Not Equal - opposite above, jump is made when zero flag is clear

NES Code Structure
Getting Started
This section has a lot of information because it will get everything set up to run your first NES program. Much of the code can be copy/pasted then ignored for now. The main goal is to just get NESASM to output something useful.

iNES Header
The 16 byte iNES header gives the emulator all the information about the game including mapper, graphics mirroring, and PRG/CHR sizes. You can include all this inside your asm file at the very beginning.

  .inesprg 1   ; 1x 16KB bank of PRG code
  .ineschr 1   ; 1x 8KB bank of CHR data
  .inesmap 0   ; mapper 0 = NROM, no bank swapping
  .inesmir 1   ; background mirroring (ignore for now)

Banking
NESASM arranges everything in 8KB code and 8KB graphics banks. To fill the 16KB PRG space 2 banks are needed. Like most things in computing, the numbering starts at 0. For each bank you have to tell the assembler where in memory it will start.

  .bank 0
  .org $C000
;some code here

  .bank 1
  .org $E000
; more code here

  .bank 2
  .org $0000
; graphics here

Adding Binary Files Additional data files are frequently used for graphics data or level data. The incbin directive can be used to include that data in your .NES file. This data will not be used yet, but is needed to make the .NES file size match the iNES header.

  .bank 2
  .org $0000
  .incbin "mario.chr"   ;includes 8KB graphics file from SMB1

Vectors
There are three times when the NES processor will interrupt your code and jump to a new location. These vectors, held in PRG ROM tell the processor where to go when that happens. Only the first two will be used in this tutorial.

NMI Vector - this happens once per video frame, when enabled. The PPU tells the processor it is starting the VBlank time and is available for graphics updates.
RESET Vector - this happens every time the NES starts up, or the reset button is pressed.
IRQ Vector - this is triggered from some mapper chips or audio interrupts and will not be covered.

These three must always appear in your assembly file the right order. The .dw directive is used to define a Data Word (1 word = 2 bytes):

  .bank 1
  .org $FFFA     ;first of the three vectors starts here
  .dw NMI        ;when an NMI happens (once per frame if enabled) the 
                   ;processor will jump to the label NMI:
  .dw RESET      ;when the processor first turns on or is reset, it will jump
                   ;to the label RESET:
  .dw 0          ;external interrupt IRQ is not used in this tutorial

Reset Code
The reset vector was set to the label RESET, so when the processor starts up it will start from RESET: Using the .org directive that code is set to a space in game ROM. A couple modes are set right at the beginning. We are not using IRQs, so they are turned off. The NES 6502 processor does not have a decimal mode, so that is also turned off. This section does NOT include everything needed to run code on the real NES, but will work with the FCEUXD SP emulator. More reset code will be added later.

  .bank 0
  .org $C000
RESET:
  SEI        ; disable IRQs
  CLD        ; disable decimal mode

Completing The Program
Your first program will be very exciting, displaying an entire screen of one color! To do this the first PPU settings need to be written. This is done to memory address $2001. The 76543210 is the bit number, from 7 to 0. Those 8 bits form the byte you will write to $2001.

PPUMASK ($2001)

76543210
||||||||
|||||||+- Grayscale (0: normal color; 1: AND all palette entries
|||||||   with 0x30, effectively producing a monochrome display;
|||||||   note that colour emphasis STILL works when this is on!)
||||||+-- Disable background clipping in leftmost 8 pixels of screen
|||||+--- Disable sprite clipping in leftmost 8 pixels of screen
||||+---- Enable background rendering
|||+----- Enable sprite rendering
||+------ Intensify reds (and darken other colors)
|+------- Intensify greens (and darken other colors)
+-------- Intensify blues (and darken other colors)

So if you want to enable the sprites, you set bit 3 to 1. For this program bits 7, 6, 5 will be used to set the screen color:

  LDA %10000000   ;intensify blues
  STA $2001
Forever:
  JMP Forever     ;infinite loop

Putting It All Together
Download and unzip the background.zip sample files. All the code above is in the background.asm file. Make sure that file, mario.chr, and background.bat is in the same folder as NESASM3, then double click on background.bat. That will run NESASM3 and should produce background.nes. Run that NES file in FCEUXD SP to see your background color! Edit background.asm to change the intensity bits 7-5 to make the background red or green.

You can start the Debug... from the Tools menu in FCEUXD SP to watch your code run. Hit the Step Into button, choose Reset from the NES menu, then keep hitting Step Into to run one instruction at a time. On the left is the memory address, next is the hex opcode that the 6502 is actually running. This will be between one and three bytes. After that is the code you wrote, with the comments taken out and labels translated to addresses. The top line is the instruction that is going to run next. So far there isn't much code, but the debugger will be very helpful later.


NEXT WEEK: more PPU details, start of graphics

Is there any documentation about NESASM3? It'd be nice to see what it can or can't do. I wasn't able to find anything on the web. Then again, I've noticed I'm not as patient in my searches as I used to be : P

It seems to be able to make fairly simple games without too much problem.  I've not tried anything more sophisticated like mapper use.  What specifically do you want to do?

Side note:  NESASM has a tendency to be bashed for being a bad assembler.  It's a good teaching assembler, I suppose, but for any future projects, I'm going to look at others and see if they truly are better.

Well, I was using a different assembler before (was learning it). NESASM wasn't at version 3 before, so I was wondering what has been done to it. Like you said, it's supposed to be pretty good for smaller games, so I was going to check out what it can do in terms of macros and the like (if at all). Anyway, I'm sure I'm going to stick with what I'm using now, which is ca65, but I'm curious to know what has been tweaked in NESASM.

Mostly the changes I made for version 3 were removing some illegal instructions (like inc a), changing the () vs [] syntax, and generating a function listing file. I think other than that it is the same as previous versions. At some point I plan to add more header directives for things like the battery info. I put the old version of the usage doc at http://www.nespowerpak.com/nesasm...

If you are already getting ca65 to produce good .nes files then it should be no problem to stick with. You may also want to look at ASM6 if you want something other than ca65.

Just curious, Roth:  Are you making a full-fledged game or just learning to make?

bunnyboy:
Alright, I wasn't sure if NESASM was greatly expanded on or not since it was going from 2.xx to ver 3. I was just curious : ) I had a great deal of help getting ca65 setup though, which at first I had used p65. I'll look up ASM6 to see what that's all about, thanks!

Sivak:
It's more like a demo, but... I don't know, it's not really a game, but not really a demo haha It's something to get my feet wet for the most part. You can get the latest upload here:

http://roth.zhxhome.net/games/index.htm

It's a bit further along than that now. Different title screen, the cat sprite tiles are pulled onto the screen, and the checkmark on the notepad in the bottom left actually stop at each selection instead of moving up and down really fast haha You'll also notice that when you come back from the instruction screen in this upload, that the little "Decepticon looking cat-head" is in the wrong spot. That's fixed also.

Right now I'm trying to come up with a better controller routine using EORs and ANDs (something recommended to me, now I just have to figure it out). Also, changing sprites when the button is pressed. That's a whole different issue. Anyway, yeah, you can check it out in the link above. Not much, but at least I'm learning : )

I see.  Well, it seems interesting.  You got drawing routines down pretty well.

Was that NSF made with Famitracker?

Be sure to check out my game as well:
http://www.nintendoage.com/forum/messageview.cfm?catid=22&th...

Nah, I used NerdTracker2 because that's what I knew at the time. I'm just now checking out FamiTracker since it has the option to have multiple songs in an .nsf.

I checked your game out last night, and I suck at it haha! I'll have to figure it out sometime : ) Good job!

Hi Bunnyboy,

 I dont know if its my browser, but I notice a lot of the code snippets above are showing up altogether on the same line.   So if I was to copy and paste those into a file,  it obviously wouldnt compile.

The only other comment I would make would be mentioning something about CONSTANTS or DEFINES

I can see that you have some declared for PPUMASK, etc.. in the code  but there is no separate heading for them like you have for COMMENTS and OPERANDS.  That threw me for a loop since the syntax is slightly different for those constants between different assemblers.

Keep up the good work

Al

I'm wondering if that's a result of the new layout. It wasn't like that before, and this is the first time I came back to this thread since the changeover.

Hi,

I'm new to this, so these may be dumb questions.

In background.asm

In the vblankwait1: section
What does BIT and BPL mean?

In the clrmem: section
You increment x and then branch if not equal
I thought you had to do some kind of comparison on the line before BNE
What is the BNE comparing to? What values must be equal to continue and not jump back to clrmem:?





Thanks

Those are opcodes, you should get an assembly manual for the 6502. I'm sure there's a complete one online somewhere. BIT tests bits in the accumuluator. BPL means branch result plus. It checks the status of flag N. If you don't know what that means, it's highly recommended you read through a 6502 Assembly book. I believe Zaks did one awhile ago that's quite good. Not familiar with it, but I Have his Z80 Assembly book and it's boss.

BNE will cause a branch if the result is not zero, right?

Oh, and you probably shouldn't listen to anything I say. I'm about a half-step above NoobExtreem(TM). Okay, I'm going to stop posting now. Bye.

BNE in this case kind of functions like "jump if not zero".  So basically, the loop increases until it hits the number 255 (FF in hex).  The next increment in would normally make it be 256, but in the world of 8 bit,  it goes back to 0 and the branching stops because you're at 0.

I think the way it works is the zero flag gets set, and that's what stops the branching.


The loop could also have been set up like this:
  LDX #$FF
.loop:
  ;Do whatever code you want
  DEX
  BNE .loop


That's the best way to do most counting loops.

Except that loop will only run 255 times, not 256.  When the loop is run with X=1, the dex makes X=0, and it ends.  The 0th time thro the loop is never run.  To make it correct it should be ldx #$00 at the top.

Thanks for clearing that up!


Keep up the good work bunnyboy, these tutorials are helping me immensely.

have a problem with the exsample.

I downloaded the background and unzipped it.Then when i put it in the nesasm 3 and try to open it(by double clikking background.bat),i get a message that asm3 is not recognized as intern or extern mission or program?

Whats going on? is nesasm3 dos instead of windows or something?

If the NESASM3.exe file is in the same directory as the Bat file, try changing the Bat file to be "NESASM3.exe background.asm"

Changing it does not help

Still think that DOS is the problem

I can open and see the mario.chr and the background.asm. Only the background.bat wont open,black screen with not recognized bla bla

NESASM3 isn't included in the background.zip file, click on the NESASM3 link in the article to download it separately.

thats not the problem.

 have downloaded the background zip, the nesasm3 en de fceuxd sp

i have unzipped the background and have put it in the nesasm3 but when i try to dubbel click the bat file the nesasm3 programm is not recignized as a internal or ext. programm or command?

take a screenshot of the folder everything is in and the window with error message

Finaly had some time to work on this again.
tried again and got something working i unzipped the background and nesasm and trew the background in the nesasm that became background.fns threw it in again and it became background.nes

BUT if i trow it in a emulator i only get a grey screen?
do have to ad something to the background code?