1
How To Use This Book
Although anyone wishing
to learn 6502 machine language (ML) will likely find this book
instructive and worthwhile, the specific example programs are
written to work on five popular personal computers: Apple, Atari,
VIC, Commodore 64, and the PET/CBMs. If your computer uses the 6502
microprocessor, but is not one of these machines, you will need to
find a "memory map" for your particular machine. These maps - widely
available in books and magazines, and from user groups - will allow
you to follow and practice with the examples of 6502 machine
language throughout this book. In particular,
there are several memory addresses which are used in many of the
examples presented in this book. Their addresses are given for the
five computers mentioned above, but if you have a different
computer, you should look them up in a map of your
machine: 1. "Which key is pressed?"
This is an address, usually somewhere in the first 256 addresses,
which is always holding the value of the most recently pressed key
on the keyboard. 2. Starting Address of
RAM Screen Memory. This is the address in your computer where,
if you POKEd something into it from BASIC, you would see the effect
in the upper left-hand corner of your screen.
3. Print a Character. This address is within your BASIC
ROM memory itself. It is part of the BASIC language, but written in
ML. It is the starting address of a routine which will put a
character on the screen. 4. Get a
Character. Also part of BASIC in ROM memory, this ML routine
accepts a character from the keyboard and stores it.
5. A safe place. You must know where, in your
computer, you can construct ML programs without interfering with a
BASIC program or anything else essential to the computer's normal
operations. The best bet is often that memory space designed to
serve the cassette player called the cassette buffer. While
practicing, you won't be using the cassette player and that space
will be left alone by the computer itself.
Here are the answers to give the Simple Assembler (Appendix C)
when it asks for "Starting Address." These are hexadecimal numbers
about which we'll have more to say in the next chapter. For now, if
you've got an Atari, type in 0600. If you use a PET/CBM, answer
0360. For VIC or Commodore 64, type: 0340. If you have an Apple, use
0300. For other computers, you'll need to know where there are about
100 RAM memory addresses that are safe. All
through this book, the examples will start at various arbitrary
addresses (1000, 2000, 5000, for example). You should substitute the
addresses which are safe in your computer. Just as it doesn't matter
whether you start a BASIC program at line number 10 or line 100, it
makes no difference whether a ML program starts at address 1000 or
0340, as long as you are putting it in a safe memory zone.
So, start all of the examples you assemble for practice
in the same convenient, safe memory location for your machine. In
fact, the Simple Assembler (SA) was designed to be modified and
customized. See the introduction to Appendix C for more detailed
instructions on customizing. Because you can make the SA conform to
your needs, you might want to replace the line with the INPUT that
requests the starting address (variable SA) with a specific address.
In this way, you can work with the examples in the book without
having to specify the safe address each time.
The First Step:
Assembling Throughout this book there are many short
example ML programs. They vary in length, but most are quite brief
and are intended to illustrate a ML concept or technique. The best
way to learn something new is most often to just jump in and do it.
Machine language programming is no different. Machine language
programs are written using a program called an assembler, just as
BASIC programs are written using a program called "BASIC."
In Appendix C there is a program called the "Simple
Assembler." Your first step in using this book should be to type in
the Microsoft version; it will work correctly on all personal
computers using Microsoft BASIC. (If you have an Atari, type in the
Atari version.) Once you've typed this
program into your computer, you can save it to tape or disk and use
it whenever you want to construct a ML program. The example ML
routines in this book should be entered into your computer using the
Simple Assembler and then modified, examined, and played
with. Frequently, the examples are designed
to do something to the screen. The reason for this is that you can
tell at once if things are working as planned. If you are trying to
send the message "TEST STRING" and it comes out "test string" or
"TEST STRIN" or "TEST STRING@" - you can go back and reassemble it
with the SA until you get it right. More importantly, you'll
discover what you did wrong. What you see on
the screen when you POKE a particular number to the screen will
differ from computer to computer. In fact, it can vary on different
models of the same computer. For this reason, the examples in the
book are usually given in standard ASCII codes (explained
later). Chances are that your computer uses a
particular code for the alphabet which is not ASCII. The Commodores
use what's called "PET ASCII" and the Atari uses ATASCII, for ATari
ASCII. It's not that bad, however, since once you've found the
correct number to show the letter "A" on screen, the letter "B" will
be the next higher number. If you don't have a chart of the
character codes for your computer's screen POKES, just use this
BASIC program and jot down the number which is used to POKE the
uppercase and lowercase “A.”
10 FOR I=0 TO 255: POKE
(your computer's start-of-screen-RAM address), I:
NEXT
With that knowledge, you can easily achieve the
exact, predicted results for the examples in the book by
substituting your computer's code.
A Sample
Example The following illustrations will show you how
to go about entering and testing the practice examples in the book.
At this point, of course, you won't recognize the ML instructions
involved. The following samples are only intended to serve as a
guide to working with the examples you will come upon later in the
text. After you've typed in and saved the SA,
you can RUN it (it's a BASIC program which helps you to write ML).
The first thing it does is ask you where you want to start your ML
program - where you want it stored in memory. This is why you need
to know of a safe place to put ML programs in your
computer. Of course you use line numbers when
creating a BASIC program. Line numbers are not used in ML
programming. Instead, you can think of memory addresses as "line
numbers." So, if you are using the Atari, you will tell the SA that
you are going to start your ML program at 0600. It will then print
0600 on the screen as if it were a line number, and you enter a ML
program instruction, one per line, like this:
0600
PLA (This PLA is
always required in the Atari when you use USR.) 0601
LDY #00 (Stay in the hexadecimal
mode for this example.) 0603 LDA #21 0605
STA (58)Y 0608 RTS 0609
END
The SA will automatically
print each "line number" address when you are programming. You just
type in those now mysterious ML instructions. This program will put
the letter "A" on screen. After you are finished with an example,
you type the word "END" and the SA will tell you the starting
address of your ML program in RAM memory. The
next step is to try out the ML program you've written to see that it
will work as planned. On the Atari, you could type:
X=USR(1536) (and hit
RETURN)
and this will "RUN" your ML program. You will
have sent control of the computer from BASIC to your new ML program
via the USR command. Be sure to remember that the Atari requires the
PLA as the first instruction of each ML program that you plan to go
to from BASIC by using the USR command. In all the examples in
this book, type in a PLA as the first instruction before continuing
with the rest of the example if you use an Atari.
Most personal computers use Microsoft BASIC, and the
PLA is not necessary. Here's how the same example would look on a
PET/CBM after you answered 0360 as the starting address when the SA
asked for it:
0360 LDY #01 0362 LDA
#41 0364 STA 8000 0367 RTS 0368
END (The word "END" isn't a 6502 ML
instruction; it's a special signal to the SA to stop constructing a
program and exit the SA program. Such special words are called
pseudo-ops.)
Then you could test
it in direct mode (just typing in the instruction onto the screen
with no line number and not as part of a BASIC program) by
typing:
SYS 864 and you
should see the "A" on the screen.
Notice
that the Atari and PET versions are similar, but not identical. All
6502 based computers will work with the same "instruction set" of
commands which the 6502 chip can understand. The major differences
occur when you need to specify something which is particular to the
design of your computer brand. An example would be the location in
memory of your computer's screen. The instructions at 0605 in the
Atari example and 0364 in the PET example send the code for the
letter "A" to the different screen locations for these two computer
brands. Also, the letter "A" itself is signified by the number 41 on
a PET and by the number 21 on an Atari. But
we'll go into these things further on. The main thing to learn here
is how to use the SA to practice the examples. If you type in 0600
as the starting address as in the Atari example above, the SA will
print the number 0600 on screen and wait for you to type in a 6502
instruction (PLA in this case) and hit RETURN. Then it will print
the next memory address just as if you were using an automatic line
numbering routine when programming in BASIC. After you hit RETURN,
the SA will print 0601 and wait for you to type in LDY #00.
Return to Table
of Contents | Previous
Chapter | Next
Chapter |
|