Having driven a computer before, you will be aware that something exists called 'machine code' and another thing called 'assembler'. Quite simply machine code is the language that the micro-processor chip in your computer understands, while assembly language is just the same thing in a more readable form. As an example, take a simple addition sum - adding 12 and 72. In English, you would say:
      Add twelve to seventy two - what's the answer?

In BASIC, you might say something like:

      10 A=12
      20 B=72
      30 C=A+B
      40 PRINT C

In 6502 machine code, you could say:

      A2 0C
      8E AC 0D
      A9 48
      6D AC 0D
      8D 00 64

This is pretty-well unintelligible, isn't it? Well, that's why we use assembly language. The same problem is given below in assembly language along with a brief comment on each line.

      LDX#  12           Load X register with a '12'.
      STX   3500         Store the content of X in memory location 3500.
      LDA#  72           Load the accumulator with a '72'.
      ADC   3500         Add to the accumulator, the contents of memory
                         location 3500.
      STA   25600        Store contents of accumulator in 25600 (i.e. on
                         screen).

It's easier to read that than the machine code, isn't it? With an assembler you can enter your program in assembly language and be able to read and understand it readily. All the assembler does is change the assembly language into machine code. Thus, when it sees 'LDX#', it changes it into an 'A2' and puts this into memory in the right place. Of course, it is possible to enter machine code directly into memory!

The heart of the 6502 is the accumulator (or 'A' for short) through which almost all of your data has to flow. It is basically an eight bit store that can hold a number up to 255. 6502 instructions allow you to write directly into this store using the instruction "LoaD a number into the Accumulator using the immediate mode" (This is a different sort of 'immediate' mode from that which you're used to in BASIC; it just means load 'the number immediately following'). The mnemonic for this is LDA# ('LDA hash').

Another instruction allows you to transfer a number from this store to any specified memory location. If this memory location is between 24576 and 32767, the number taken from the store will be displayed on screen. The instruction is:

You should note that all the STore and LoaD commands you will meet should really be thought of as COPY commands as they create a second copy of the data, leaving the source unaltered.

Let's have a go then at running a machine code program!

This program will put a number into the accumulator and then transfer it to a position near the bottom of the screen, i.e. location 25600.

One word about the assembler in the Electron machine. This is a part of the Electron's BASIC interpreter and can be entered simply by putting a square bracket '[' as a BASIC statement. The end of the assembly is marked by a right-hand square bracket ']'. The assembler needs to be told, when you assemble the program, where you want it to be put in the memory. You do this by setting the variable P% to the 'start address'. The memory locations starting at 8192 are used for the examples in this series.

Our assembly programs will need to be embedded within a BASIC program and hence will be written in the form:

       10 P%=8192
       20 [
       30 ......assembly statements
        . ......assembly statements
        . ......assembly statements
      100 ......assembly statements
      110 ]

N.B. You should use Mode 6 unless instructed otherwise.

When you have put in your assembly language program you must first 'assemble' it, and this is done by RUNning the BASIC program containing the assembly code. Up will come on the screen a list of your assembly program and each statement will be preceded by its machine code counterpart; this machine code being called the 'object program', the constituent parts being the 'object code'. This object code could be entered directly into memory and would yield the same results as the program you typed in; the assembly language only helps you to compile the program in the first place. The program should end in the normal way by displaying the usual basic prompt '>'.

On typing...

      CALL 8192   (8192 is the first memory location of the machine
                  code program)

the machine code will be executed. At the end of any machine code program we always tell the machine code to return to the BASIC monitor. The command that does this is ReTurn from machine code Subroutine, or RTS. (In order to avoid confusion, the word 'run' is used in connection with a BASIC program and 'execute' in connection with a machine code program) If you find this explanation confusing, don't worry, just follow through the steps one by one.

Right now, to write our first program, we must:-

• Tell the assembler that the start address is 8192, i.e. P%=8192
• Tell the assembler to start assembly, i.e. [
• LoaD number '255' into accumulator A using immediate mode. The mnemonic for this is LDA# + number to be entered, i.e. LDA#255
• STore at a specified Address, the contents of the Accumulator. The mnemonic for this is STA. After this we must tell the 6502 what the address is, i.e. STA 25600
• ReTurn to the BASIC Subroutine, i.e. RTS
• Tell the assembler to finish assembly, i.e. ]

Or

      10 P%=8192
      20 [
      30 LDA#255
      40 STA 25600
      50 RTS
      60 ]
      70 PRINT"ASSEMBLY COMPLETED"                         (Program 1.1)

Now, to enter the assembly program just type in the above. (You should be in Mode 6 - if you are not, type MODE6 <RETURN> now!)

Run this program and in the twinkle of an eye, your assembly code will be converted into a machine code program starting at 8192. (If you make a mistake you should get a helpful error message, just like BASIC! You can edit your program, just as you would with any BASIC program, using the <COPY> and LIST to list your program.)

To execute the machine code program, we just use the CALL statement in immediate mode. (Before you execute this you must clear the screen using CLS <RETURN>.) Now type:

      CALL 8182 (RETURN)   (8192 is the location of the start of the program)

So far then the achievement has been to load a number '255' into the 6502's on chip memory (the accumulator) and then to store this somewhere on the screen. As it happened, we chose the top left but it could have been anywhere. As an experiment, try changing the address specified in line 50 but you must keep it between 24576 and 32767 or you will not be on the screen at all! (You will not be in screen memory but in some other part of memory.)

Let's have a look at another instruction and use this in a program. As stated earlier, the accumulator is the repository of most 'answers' and this new instructions 'does a sum' and leaves the answer into the accumulator.

To use ADC, we have to add two extra lines to the program that gets the 6502 ready for adding. Don't worry what they mean for now - just type them in and follow the instructions! Oh yes, and don't worry about the 'with Carry' bit yet. That will become clear later on - honest!

One other point about jargon! The term instruction is used to describe an executable machine code statement. Thus, it could consist of LDA# or just RTS. However, the term is also used to refer to the mnemonic alone, as when one says the 6502 instruction set. In this series, the term command is used to refer to the mnemonic part of an instruction when this precision is required. For instance, in the instruction LDA#65, the LDA part may be referred to as the 'command'.

Let's look at the stages:

       10 P%=8192      Gives address for beginning of program
       20 [            Starts assmbling
       30 CLD          } Gets the 6502
       40 CLC          } ready for adding
       50 LDA#1        LoaD '1' into the Accumulator in immediate mode
       60 STA 25607    STore the contents of Accumulator (1) in 25607
       70 LDA#128      LoaD '128' into the Accumulator in immediate mode
       80 ADC 25607    ADd with Carry, the contents of 25607 (i.e. 1) to
                       the accumulator (i.e. 128)
       90 STA 25600    STore the contents of Accumulator (now 129) in
                       25600
      100 RTS          ReTurn from machine code Subroutine
      110 ]            End assembly

Right then, type it in!

Now run what you have just typed in and your assembly program will be assembled. (Don't forget to CLS!)

Type CALL 8192 <RETURN> and your screen will display a single dot and a pair of dots at the screen positions corresponding to 25607 and 25600 respectively. If they do not appear instantly, press <BREAK> then type OLD <RETURN>, LIST <RETURN>. Your program should appear.

Another way of looking at the two lines:

       50 LDA#1
and    60 STA 25607

is as a way of putting a '1' into memory or of putting a single dot on the screen. (The special 8-bit code for 1 is 00000001 in binary. Note that the first dot pattern has only one dot which corresponds to the '1' in the binary number 00000001. The second dot pattern has two dots which correspond to the two '1's' in the binary for 129 i.e. 10000001. These will be covered in great detail later in the course.

The 6502 has two index registers in addition to its accumulator and these are referred to as Index registers X and Y, and can each store one 8-bit number. The arrangement of these or, as the jargon has it, the architecture of the 6502, is shown below (in part) in Figure 1.1.

                                      ________________
                                     |                |           DATA
________  ______________  ___________|___  ______ ____|_________________
    ____||____      ____||____      _|___||_     |    |
   |          |    |          |    |        |   | \  / |          BUS
   | X        |    | Y        |    | ACCUM- |   |  \/  |
   | REGISTER |    | REGISTER |    | ULATOR |   | ALU  |
   |__________|    |__________|    |________|   |______|      Figure 1.1

In this figure, the X and Y registers are shown identically, although they do differ slightly. Nevertheless, they are both indexed registers and can thus have the value stored in them incremented or decremented (increased or decreased) in steps on 1. To the right of the figure is the ALU, or Arithmetic Logic Unit, in which arithmetic and logical operations are carried out. It has two inputs for the data that it manipulates and the output from the operation is fed into the accumulator. For this reason, almost all data flows through the accumulator, making this a key feature of the 6502. Data flows between various registers along the data bus which a common trackway for communication within the 6502. For talking to devices beyond the chip, this data bus is extended to access memory also.

In the remainder of this part, we will look at these registers and the ways that data can be fed in, out and between them.

First of all we'll have a go at using the X-register - so to load this we use the instruction:

Thus, LDX 9000 means LoaD index register X with the data in memory location 9000. LDX differs from the earlier LDA# (apart from one loading the accumulator and one the X-register) in that the LDA# command is an immediate (mode) load command. When the 6502 sees this it looks for what's immediately following the instruction and loads that - as data - into the Accumulator. With the new command above LDX, the 6502 looks for what follows and this specifies the address of the data.

Thus, with the instruction:

      LDX 9000

the 6502 goes to memory location 9000 to extract a copy of the data stored there and then loads that into the X-register. This instruction (as are all the register instructions) is really a copy as the data put into the X-register is copied to it and the original data remains in the original memory location.

To store the data we may use the instruction:

Thus, STX 25600 means STore contents of X-register in memory location 25600. Right, here goes. Here's the program!

       10 P%=8192      Gives address for beginning of program
       20 [            Start assembly
       30 LDA#85       Load 85 into the accumulator
       40 STA 25600    Store contents of accumulator in 25600
       50 LDX 25600    Load into X-register, contents of memory location
                       25600 (i.e. 85)
       60 STX 25607    Store contents of X-register in 25607 (i.e. 85)
       70 RTS          Return from machine code subroutine
       80 ]            End assembly

Now run this program and CALL 8192 in the usual way (remembering to clear the screen first of course!). The screen should display two rows of four dots. The first row corresponds to 25600 and the right most row to 25607. (The special binary code for 85 is 01010101. The four ones correspond to the four dots.)

By now you should be able to write simple programs so, as an exercise try the following:-

Load the accumulator directly with 81, display this in 25600. The answer appears at the bottom of this article.

Don't forget to put in the RTS at the end. If you do forget, then the 6502 will run on to see what it can find and try to execute this. If you're unlucky it will find something that crashes the system. Also make sure you clear the screen before you call machine code programs or you may find that things appear at lower or higher places on the screen than you expected, due to the Electron's method of scrolling text.

Display two dashes one above the other like an equals sign (Try addresses 26833 and 26837). One possible answer appears at the end of this article.

The Load and Store instructions that we have met so far are complemented by the corresponding Y-register instructions.

You should now know or able to interpret the following:

      LDA             ADC             STX             STY
      LDA#            ADC#            LDY             RTS
      STA             LDX             LDY#          
                      LDX#

For many operations but not all, the X and Y registers can be treated interchangeably; for instance, Program 1.3 could be written:

       10 P%=8192                         10 P%=8192
       20 [                               20 [
       30 LDA#85                          30 LDA#85
       40 STA 25600                       40 STA 25600
       50 LDX 25600                       50 LDY 25600
       60 STX 25600                       60 STY 25607
       70 RTS           Program 1.3       70 RTS           Program 1.3
       80 ]      (using X register)       80 ]      (using Y register)

Because of this interchangeability, and the need to swap data rapidly between registers during the run of a program, several instructions exist to do this automatically. They are typified by:

Using this command in Program 1.3 (to produce Program 1.4) shortens it, while maintaining the same function.

       10 P%=8192
       20 [
       30 LDA#85
       40 STA 25600
       50 TAX
       60 STX 25607
       70 RTS
       80 ]                                                Program 1.4

When run, the screen should display two dot patterns, one corresponds to 25600 and the other to 25607. Descriptions given of the codes so far have been spelled out in detail. However, as you are getting more used to the jargon, it is reasonable now to begin to abbreviate. From now on, instead of "the contents of the X-register", we will just refer to X and similarly so with the Y-register Y and accumulator A. Thus, a summary of the transfer instructions is:-

Next month, we'll move onto machine code subroutines, conditional jumps, the program counter and certain machine code flags.

Exercise 1.1

      10 P%=8192
      20 [
      30 LDA#81
      40 STA 25600
      50 RTS
      60 ]

Exercise 1.2

      10 P%=8192
      20 [
      30 LDA#255
      40 STA 26833
      50 STA 26837
      60 RTS
      70 ]

First Published EUG #49
(C) Honeyfold, Standfast House, Bath Place, Barnet, LONDON