6502 assembly code may look a bit intimidating for those who are unfamiliar, with all of the cryptic-seeming three-letter commands (opcodes). In reality, the language is pretty simple, if a bit tedious in places. There is no need to memorize the whole list of commands - you will use a subset of the available commands most frequently, and you can look up the others as you need them.

Many people recommend the Easy 6502 tutorial to learn the language. It's a well-done tutorial with a built-in assembler and debugger, but I personally preferred learning by doing actual Atari 2600 programming. That is the approach I am taking here. Feel free to check out that tutorial and learn from that instead if you wish, but come back here and go to "Putting it All Together" later in this lesson.

Note - Throughout this lesson, I show the same operations being performed with batari Basic vs assembly language. Another way to see examples of this would be to compile a bB program with the code in question, and then look at the assembly language file that bB generates (e.g. game.bas.asm).

   lda #20      ; Load the number 20 into register A   ldx #$20     ; Load the number 32 ($20 in hex notation) into register X   ldy #myconst ; Load the value of the defined constant "myconst" into register Y   lda temp1    ; Load the value stored in the variable temp1 into register A

Each of these 3 registers has an associated store command as well that can be used to store the contents of that register into memory. Note that all variables that are available in your bB program are accessible via assembly, too:

STA - Store the value in the A register into the specified memory location
STX - Store the value in the X register into the specified memory location
STY - Store the value in the Y register into the specified memory location

Some examples:

   sta temp1    ; Store the contents of A in the temp1 variable   stx temp2    ; Store the contents of X in the temp2 variable   sty myvar    ; Store the contents of Y in the myvar variable

Comparison to batari Basic

Here are some simple operations in bB, followed by how the same would be done in assembler using what we have learned so far.

batari Basic code:

   temp1 = 5   temp2 = myconst   myvar = temp3

Equivalent assembly code:

   lda #5   sta temp1   lda #myconst   sta temp2   lda temp3   sta myvar

Note that I used the A register for my assembly example here, but I could have just as easily used the X or Y registers by replacing LDA and STA with LDX and STX, or LDY and STY.

Warning - It is a common newbie mistake to leave off the "#" before loading actual numbers. Without the "#" the assembler interprets the number as a memory address. For example, lda #$91 would load the value of missile0y into the A register instead of the number $91.

Tip - If you need a way to remember clearing carry before addition and setting carry before subtraction, then think of it this way: you clear the carry before adding to have a place to put any carry from the addition operation, and you fill it before subtraction to give a place to borrow from for the subtraction operation.

   lda #14   clc   adc #27

Add the value of the "length" constant to $17 (hex):

   lda #$17   clc   adc #length

Add the value of temp2 to the value of temp1:

   lda temp1   clc   adc temp2   sta temp1

Subtraction examples:


Subtract 9 from 125:

   lda #125   sec   sbc #9

Subtract $10 (hex) from the value of the "ticks" constant:

   lda #ticks   sec   sbc #$10

Subtract the value of temp3 from temp4:

   lda temp4   sec   sbc temp3   sta temp4

Multiplication examples:


Multiply 33 by 2:

   lda #33   asl

Multiply the value of the "starting_lives" constant by 4:

   lda #starting_lives   asl   asl

Multiply the value of temp1 by 16:

   lda temp1   asl   asl   asl   asl   sta temp1

Division Examples:


Divide 132 by 2:

   lda #132   lsr

Divide the value of the "cities" constant by 8:

   lda #cities   lsr   lsr   lsr

Divide the value of temp6 by 32:

   lda temp6   lsr   lsr   lsr   lsr   lsr   sta temp6

More Comparison to batari Basic

Here's an example of arithmetic operations in bB compared to how we would perform the same in assembly language:

batari Basic code:

   temp1 = 8 + 14   temp2 = temp3 - 8   temp4 = temp4 * 2   temp5 = temp6 / 4

Equivalent assembly code:

   lda #8   clc   adc #14   sta temp1   lda temp3   sec   sbc #8   sta temp2   lda temp4   asl   sta temp4   lda temp6   lsr   lsr   sta temp5

Incrementing, Decrementing, and Looping

The X and Y registers can be easily incremented or decremented by 1 with the following commands:

INX - Increment X by 1
INY - Increment Y by 1
DEX - Decrement X by 1
DEY - Decrement Y by 1

Additionally, a variable may be incremented or decremented by 1 directly with the following commands:

INC - Increment variable by 1
DEC - Decrement variable by 1

As previously mentioned, since the X and Y registers can be easily incrememented and decremented, they are often used as counters for loops. Loops in 6502 assembly usually count down instead of up, since flags get set if the value reaches 0, or if it drops below 0, allowing us to loop on those conditions. Common commands for this include:

BNE - (Branch if Not Equal): branch to the specified address if the zero flag is not set
BPL - (Branch on PLus): branch to the specified address if the negative flag is not set

Our simple minikernel uses a loop in this way:

    ldx #14              ; Load the number 14 into Xminikernelloop    sta WSYNC    stx COLUBK    dex                  ; Decrement X by 1    bne minikernelloop   ; Branch back to minikernelloop of X is not 0    rts

Even More Comparison to batari Basic

As before, I'll show a comparison to how the same operations would be performed in bB vs assembly language:

batari Basic code:

   temp1 = temp1 + 1   temp2 = 10myloop   temp2 = temp2 - 1   if temp2 <> 0 then goto myloop

Since registers aren't used directly in bB code, the following isn't exactly equivalent, since we would probably use registers for looping instead of a temp variable:

   inc temp1   ldx #10myloop   dex   bne myloop

However, if we did not have a free register to use, we could use temp variables instead. This example is fully equivalent to the batari Basic code example:

   inc temp1   lda #10   sta temp2myloop   dec temp2   bne myloop

Putting it All Together

Now that we have gone over some common commands, it should be easier to understand our minikernel code as it exists now, and modify it a bit.

Right now, we have:

minikernel    ldx #14minikernelloop    sta WSYNC    stx COLUBK    dex    bne minikernelloop    rts

We load 14 into the X register, wait for a new scanline, store the current value of X into COLUBK, decrement X, then loop until X is 0. Based on NTSC color values, this gives a gray gradient bar. How about we make a bar that shows all 16 hues at their brightest instead?

First, just so we don't make our screen too big with the extra lines, let's get rid of the score portion of our game. This will get rid of the pips for lives, but we will replace these with graphics in our minikernel soon, anyway. At the top of cannons.bas, add the following line:

   const noscore=1

Now, when we compile, we will see this:



Now, how to modify our code? Let's change ldx #14 to ldx #16 since we will be displaying 16 different color lines.

Also, we won't be storing X in COLUBK anymore, so we will need to use another register. Looking at the color chart, value 15 is bright white. Bright yellow is 31, bright orange is 47, etc., with each being 16 apart. We can therefore add 16 on each line, and store the new value in COLUBK.

Since we are talking about doing addition, we will need to use the accumulator (register A).

We first load 15 into the accumulator before the loop, and we add 16 to on each loop iteration:

minikernel    ldx #16   ; 16 loop iterations    lda #15   ; Start with bright white color valueminikernelloop    sta WSYNC    sta COLUBK    clc        ; Clear the carry flag before addition    adc #16    ; Add 16 to jump to next color    dex    bne minikernelloop    rts

Now let's see how that looks:


Very pretty! It kind of makes me want to replace the cannons with unicorns. :-)

Summary and Next Lesson

We have covered some of the most common assembler commands that you will use when making minikernels. A 6502 assembly language tutorial exists for those who wish to learn that way. The language itself is not difficult, and there is no need to memorize the whole list. Here are two assembly language command reference pages that I use:

• 6502 Opcodes
• 6502 Reference
  

In the next lesson, we will cover pointers to data, and drawing player graphics in our minikernel.