informis/textfiles
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
master
textfiles/apple/mllessons.txt
T
root@procul 278a90f7ce Initial commit
2021-04-15 13:31:59 -05:00

925 lines
26 KiB
Plaintext
Raw Permalink Blame History

**************************************************************
* MACHINE LANGUAGE TUTORIAL *
* *
* *
* BROUGHT TO YOU BY: *
* *
* THE SHOALIN TEMPLE OF THE DRAGON BBS *
* ([408] 739-5370) *
**************************************************************
MACHINE CODE
BY
TOM O'BRIEN
[EDITOR'S NOTE: THIS TUTORIAL FROM TOM O'BRIEN OF THE GREEN APPLE
USERS GROUP IN CEDAR FALLS IOWA IS DERIVED FROM A SERIES OF LESSONS ON
MACHINE LANGUAGE PROGRAMMING WHICH WERE DISTRIBUTED ON A TUTORIAL DISK
PRODUCED BY THAT CLUB. I HAVE TAKEN THE LIBERTY OF ALTERING HIS WORK
TO SUIT THE FORMAT OF THIS DISK. ]
INTRODUCTION
IT IS DIFICULT TO TELL WHERE TO START WITH SOMETHING LIKE THIS COURSE.
MAYBE "COURSE" ISN'T THE RIGHT WORD. WHAT I HOPE TO BE ABLE TO DO IS
TO GIVE YOU A ROADMAP WHICH YOU CAN FOLLOW TO EXPLORE THE INSIDE
WORKINGS OF YOUR COMPUTER. I'LL TRY TO START OUT WITH LOTS OF DETAILS
SO YOU CAN TELL WHICH WAY TO GO. AS THINGS GO ON, THE DETAILS WILL GET
LEFT BEHIND. THEY WILL BE THINGS FOR YOU TO FIGURE OUT ON YOUR OWN.
I'M NOT GOING TO DO THE WORK FOR YOU. I'LL TRY TO ANSWER QUESTIONS YOU
HAVE AND I'LL TRY TO HELP YOU....BUT, YOU WILL HAVE TO DO THE WORK
YOURSELF.
STARTING WITH THE MINI-ASSEMBLER
WE WILL USE THE MINI-ASSEMBLER THAT IS AVAILABLE IN INTEGER BASIC. IF
YOU HAVE AN INTEGER CARD OR A LANGUAGE CARD (16K RAM CARD) OR HAVE A
64K MACHINE (EG THE APPLE //E), THEN THE MINI- ASSEMBLER IS AVAILABLE
TO YOU. IF YOU HAVE AN APPLE ][ PLUS WITHOUT A 16K RAM CARD, YOU WILL
NEED TO ACCESS THE MINI-ASSEM BLER FROM THE FILE ON THIS COPY OF THE
IAC MACHINE LANGUAGE UTILITIES DISK.
I WON'T TRY TO TELL YOU WHAT A MINI-ASSEMBLER IS AT THIS TIME, OTHER
THEN IT IS A TOOL WHICH WILL HELP YOU TO CREATE MACHINE LANGUAGE
PROGRAMS.
LET'S START WITH A SIMPLE PROGRAM.
ENTER:
]CALL-151
TO JUMP INTO THE APPLE'S MONITOR.
* IS THE PROMPT CHARACTER WHICH INDICATES THAT YOU ARE IN THE HEART OF
THE MACHINE.
TYPE IN THE FOLLOWING:
1000:A9 C8 8D 48 06
1000G
YOU SHOULD SEE THE CHARCTER "H" ON THE THE RIGHT HAND SIDE IN THE
MIDDLE OF THE SCREEN.
TYPE IN THE FOLLOWING:
1000:A9 C5 8D 48 06
1000G
YOU SHOULD NOW SEE THE CHARACTER "E" WHERE THE "H" WAS LOCATED.
BY NOW YOU MAY BE WONDERING WHERE THIS IS LEADING TO. MACHINE CODE IS
A LOT CLOSER TO THE ACTUAL HEART OF THE MACHINE THAN IS BASIC. THERE
ARE SOME ADDRESSES THAT YOU MUST KEEP TRACK OF (EG $0648 IS AN ADDRESS
IN THE LOW-RES SCREEN). THERE ARE NUMBERS WHICH YOU MUST KEEP TRACK OF
(EG. $C8 IS "H" AND $C5 IS "E").
YOU MUST THINK IN TERMS OF HEXADECIMAL INSTEAD OF DECIMAL. $1000 IN
HEX IS 4096 IN DECIMAL.
4096 256 16 1
1000 100 10 1
$100 IN HEX IS 256 DECIMAL $ 16 IN HEX IS 22 DECIMAL $ A IN HEX IS 10
DECIMAL
IN BASIC WE COULD HAVE THE STATEMENT
GET A$
IN ASSEMBLY LANGUAGE WE WOULD HAVE SOMETHING LIKE:
1000: LDA $C000
1003: BPL $1000
AS WE WILL SEE IN THE LESSON ON THE KEYBOARD, $C000 IS A PHYSICAL
ADDRESS OR LOCATION WHICH REFERS TO THE APPLE'S KEYBOARD. WHEN A KEY
HAS BEEN PRESSED THE ADDRESS $C000 WILL BE NEGATIVE. (ANOTHER WAY OF
SAYING THE SAME THING IS THAT ITS HIGH BIT WILL BE SET OR EQUAL TO ONE
WHEN A KEY IS PRESSED.)
TO RESET THE KEYBOARD SO THAT WE CAN TELL WHEN ANOTHER KEY HAS BEEN
PRESSED WE HAVE TO LOOK AT ADDRESS $C010. BY STORING SOMETHING OR
GETTING SOMETHING AT THAT ADDRESS ($C010), THE COMPLEMENTARY LOCATION
$C000 IS NOW READY TO CAPTURE AND HOLD THE CODE FOR THE NEXT KEY THAT
IS PRESSED. (STORING OR WRITING TO $C010 CAUSES THE HIGH BIT AT $C000
WILL GO LOW [=0]).
IT MIGHT BE PARENTHETICALLY ADDED THAT THE APPLE II REFERENCE MANUAL
IS OF GREAT HELP IN UNDERSTANDING MACHINE CODE ON THE APPLE. THE
MANUAL HAS CHARTS AND LISTS ON THE ACTUAL ADDRESSES THAT WE WILL NEED
TO KNOW. JUST LIKE YOU MUST KNOW SOMEONE'S MAILING ADDRESS TO SEND
THEM A LETTER, YOU MUST KNOW YOUR COMPUTER'S ADDRESSES TO DISPLAY
SOMETHING ON THE SCREEN. (IT HAS MORE THAN ONE SCREEN). THE APPLE II
REFERENCE MANUAL WILL THEREFORE BE USED TO FIND LOCATIONS INSIDE THE
COMPUTER LIKE WE WOULD USE A PHONE BOOK TO LOOK UP A FRIENDS ADDRESS.
LETS GO INTO THE MINI-ASSEMBLER:
]INT
> CALL -151
* F666G
NOW ENTER:
!1000:LDA #$C1
STA $0468
LDA #$C2
STA $0469
AS YOU TYPE IN THE ABOVE, YOU WILL SEE:
1000- A9 C1 LDA #$C1
1002- 8D 68 04 STA $0468
1005- A9 C2 LDA #$C2
1007- 8D 69 04 STA $0469
A WORD OF EXPLANATION:
1000 IS THE ADDRESS OF A9 WHICH IS THE MACHINE CODE FOR LOAD THE
ACCUMULATOR (LDA) IMMEDIATELY. 1001 IS THE ADDRESS OF C1 WHICH IS THE
HEXADECIMAL NUMBER THAT WILL BE LOADED INTO THE ACCUMULATOR. LDA #$C1
IS A EASIER WAY FOR US TO DEAL WITH THE MACHINE.
1002 IS THE ADDDRESS OF 8D WHICH IS THE MACHINE CODE FOR STORE WHAT IS
IN THE ACCUMULATOR (STA) AT THE ABSOLUTE ADDRESS IN THE NEXT TWO
BYTES, IN THIS CASE 1003 AND 1004.
IF THIS DOESN'T MAKE SENSE TO YOU, PLEASE KEEP AT IT. HOPEFULLY AS
YOU SEE AND FOLLOW MORE EXAMPLES, THE FOG WILL LIFT A LITTLE.
NOW LET'S RUN THE ROUTINE BY JUMPING TO MEMORY LOCATION $1000 WITH THE
MINI-ASSEMBLER COMMAND
! $1000G
(THIS TELLS THE APPLE TO GO TO LOCATION $1000 AND START EXECUTING
WHAT'S THERE.)
WHAT HAPPENED? DID ANY CHARACTERS APPEAR ON THE SCREEN? WERE THEY "A"
AND "B"? WERE THEY NEXT TO EACH OTHER?
IN STARTING TO LEARN MACHINE LANGUAGE PROGRAMMING, IT IS COMMON TO USE
THE LOW-RESOLUTION SCREEN... GETTING TO KNOW HOW WE CAN CONTROL WHAT
IS ON THE SCREEN. WE WILL INPUT DATA FROM THE KEYBOARD AND DISPLAY IT
ON THE SCREEN.
LETS' GO BACK TO THE MINI-ASSEMBLER AND ENTER:
*F666G
! 1000: LDA $C000
BPL $1000
STA $0468
LDA $C010
JMP $1000
AS YOU TYPE IN THE ABOVE, YOU SHOULD SEE
1000- AD 00 C0 LDA $C000
1003- 10 FB BPL $1000
1005- AD 68 04 STA $0468
1008- AD 10 C0 LDA $C010
100B- 4C 00 10 JMP $1000
! $1000G
NOW PRESS DIFFERENT KEYS ON YOUR COMPUTER. TRY CONTROL CHARACTERS...
WHAT DOES ESCAPE LOOK LIKE? WHAT DOES A RETURN LOOK LIKE?
CAN YOU GET OUT OF THE PROGRAM? DOES CONTROL-C STOP IT?
ONE THING YOU PROBABLY KNOW IS THAT IF YOU HAVE AN OLD APPLE ][
WITHOUT THE AUTOSTART ROM, HITTING THE RESET KEY WILL EXIT FROM THE
MINI-ASSEMBER INTO THE MONITOR (* PROMPT). WITH THE NEWER AUTOSTART
ROM MADE IN THE PAST COUPLE OF YEARS, EXITING THE MONITOR CAN BY DONE
BY THE RESET WHICH DUMPS YOU TO APPLESOFT AND THEN RE-ENTER THE
MONITOR BY
>CALL -151
OR REQUIRES THE COMMAND:
! $FF69G
WHICH TELLS THE COMPUTER TO GO TO THE MACHINE LANGUAGE LOCATION $FF69
AND DO WHATEVER IS THERE.
LET'S LOOK AT THE LAST PROGRAM WE RAN.
1000- AD 00 C0 LDA $C000
THIS COMMAND MEANS LOAD THE ACCUMULATOR WITH THE VALUE OF THE BYTE
THAT IS AT HEXIDECIMAL ADDRESS $C000. THIS IS THE ADDRESS OF THE
KEYBOARD, AND SO THIS LINE OF CODE LOOKS AT THE KEYBOARD.
THE NEXT LINE IS:
1003- 10 FB BPL $1000
WHICH IS BRANCH POSITIVE TO $1000 (OR BRANCH ON PLUS TO $1000). 10 IS
THE OP CODE...BRANCH POSITIVE FB IS THE OFFSET....HOW FAR TO BRANCH
TO DIGRESS TO THE PROGRAM COUNTER (PC) FOR A MOMENT, WHEN THE
MICROPROCESSOR GETS CODE, THE PROGRAM COUNTER POINTS AT 1005, WHICH IS
ONE BYTE PAST THE INSTRUCTION BEING EXECUTED. WE ADD $FB TO THE LOW
BYTE OF THE PROGRAM COUNTER, $05
$FB+$05= $00 DISREGARD CARRY
PUTTING THE PROGRAM COUNTER, PC, BACK TOGETHER, WE BRANCH TO MEMORY
LOCATION $1000 IF THE ACCUMULATOR IS POSITIVE AFTER BEING LOADED WITH
THE VALUE OF THE BYTE THAT IS IN $C000.
THIS CAUSES THE PROGRAM TO STAY IN THE LOOP
1000- LDA $C000
1003- BPL $1000
UNTIL A KEY IS PRESSED. THE EQUIVALENT BASIC PROGRAM WOULD BE:
10 X = PEEK ( - 16384 )
20 IF X >= 128 GOTO 10
30 REM CONTINUE...
IF YOU ARE INTERESTED IN TECHNICAL DESCRIPTIONS, HERE IS WHAT
HAPPENED. PRESSING A KEY SETS CLOCKS THE "D" VALUE OF A D- FLIP FLOP
INTO THE "Q" OUTPUT. SINCE "D" IS TIED HIGH, THE "Q" OUTPUT GOES HIGH.
THIS IS BIT 8 (THE HIGH BIT) OF WHAT IS AT $C000. FOR THOSE OF YOU WHO
KNOW HARDWARE, THE FLIP-FLOP IS A 74LS74 AT LOCATION B-10 ON THE
APPLE'S MOTHERBOARD.
ONCE THE KEY IS PRESSED AND $C000 IS NEGATIVE (A NUMBER IS NEGATIVE IF
ITS HIGH BIT IS SET), WE FALL THROUGH THE BRANCH INSTRUCTION
1005- STA $0468
THIS INSTRUCTS THE CPU (MICROPROCESSOR) TO STORE WHAT IS IN THE
ACCUMULATOR AT LOCATION $0468. $0468 IS ONE LOCATION IN THE LOW- RES
SCREEN, PAGE ONE.
THE NEXT INSTRUCTION IS
1008- LDA $C010
OR LOAD THE ACCUMULATOR WITH WHAT IS AT $C010. THIS WILL CLEAR THE
FLIP-FLOP THAT WAS SET WHEN A KEY WAS PRESSED. THE ADDRESS $C010 IS
DECODED BY SEVERAL CHIPS AND SENT THROUGH A NOR GATE (74LS02 AT
LOCATION A12) TO THE CLEAR INPUT OF THE FLIP-FLOP AT LOCATION B10. NOW
WHEN WE LOOK AT LOCATION $C000 THE HIGH BIT WILL BE LOW AND THE NUMBER
WE SEE WILL BE POSITIVE. (ONE NOTE:THE HIGH BIT OF THE FLIP-FLOP IS
HELD LOW DURING POWER-UP OR A RESET)
THE NEXT INSTRUCTION IS
100B- JMP $1000
OR JUMP TO LOCATION $1000 WHICH GETS THE NEXT KEYSTROKE AND STARTS THE
PROCESS OVER AGAIN.
LESSON THREE
LET'S USE A SHORT MACHINE CODE PROGRAM WITH A BASIC PROGRAM.
GO TO BASIC (USE INTEGER BASIC IF YOU HAVE IT, TO AVOID RELOADING THE
MINI-ASSEMBLER AGAIN).
10 CALL 4096
20 END
GO TO MONITOR
CALL-151
* F666G (OR WHATEVER CALL GETS THE MINI-ASSEMBLER)
! 1000: LDA #$B1
1002: STA $0770
1005: RTS
* $9DBFG RETURN TO BASIC THRU DOS
RUN
WHAT HAPPENED? DID YOU SEE "1" ON THE SCREEN IN THE LOWER RIGHT HAND
SIDE?
LINE 10....CALL 4096
IF WE CONVERT 4096 TO HEXIDECIMAL WE END WITH $1000. THIS IS THE
ADDRESS ON THE SHORT MACHINE CODE PROGRAM WE WROTE. THE BASIC LINE
INSTRUCTED TO COMPUTER TO JUMP TO THE MACHINE LANGUAGE SUBROUTINE AT
MEMORY LOCATION 4096 AND EXECUTE THE INSTRUCTIONS THERE.
OUR MACHINE CODE PROGRAM LOADS THE ACCUMULATOR WITH THE HEX NUMBER $B1
AND THEN STORES THE ACCUMULATOR IN THE LOW-RES SCREEN AT LOCATION
$0770.
WE THEN DID A "RTS" WHICH STANDS FOR RETURN FROM SUBROUTINE. THE
PROGRAM RETURNS TO THE PROGRAM THAT CALLED IT, WHICH IN THIS CASE IS
THE SHORT BASIC PROGRAM.
LATER WE WILL LOOK AT WHAT IS CALLED THE STACK AND THE STACK POINTER
AND SEE HOW TO USE IT. (THE STACK IS THE AREA OF MEMORY FROM $0100 TO
$01FF. THE STACK POINTER IS A NUMBER BETWEEN $00 AND $FF.)
MEANWHILE, LET'S DO ANOTHER SHORT PROGRAM.
GO TO MONITOR.
CALL-151
AND ENTER THE MINI-ASSEMBLER WITH
*F666G (OR WHEREVER YOU HAVE LOCATED IT. IT MAY BE NECESSARY TO RELOAD
THE MINI-ASSEMBLER IF YOU WERE IN APPLESOFT.)
! NOW WE ARE IN THE MINI-ASSEMBER
! 1000: LDA #$00
STA $0400
INC $1001
INC $1003
JMP $1000
THIS SHOULD LOOK LIKE:
1000- A9 00 LDA #$00
1002- 8D 00 04 STA $0400
1005- EE 01 10 INC $1001
1008- EE 03 10 INC $1003
100B- 4C 00 10 JMP $1000
THE FIRST LINE: LDA #$00 LOAD THE ACCUMULATOR IMMEDIATELY WITH THE
HEX NUMBER $00.
THE SECOND LINE: STA $0400 STORE THE VALUE IN THE ACCUMULATOR IN
MEMORY LOCATION $0400.
THE THIRD LINE: INC $1001 INCREMENT MEMORY LOCATION $1001 OR, SAID IN
ANOTHER WAY, ADD ONE TO THE VALUE THAT IS IS IN MEMORY LOCATION
$1001.
THE FOURTH LINE: INC $1003 INCREMENT MEMORY LOCATION $1003 OR, SAID
ANOTHER WAY, ADD ONE TO THE VALUE IN MEMORY LOCATION $1003.
THE FIFTH LINE: JMP $1000 JUMP TO MEMORY LOCATION $1000 WHICH IS THE
START OF OUR PROGRAM.
BEFORE YOU RUN THIS PROGRAM, TRY TO STEP THROUGH THE PROGRAM. CAN YOU
PREDICT WHAT IT IS GOING TO DO?
NOW, GO TO BASIC (INTEGER IF POSSIBLE)
> CALL-151
* F666G
! TYPE IN THE PROGRAM. WE ARE IN THE MINI-ASSEMBLER.
WHEN YOU ARE FINISHED, ENTER THE MONITOR WITH
! $FF69G
OR GO TO BASIC AND ENTER THE MONITOR WITH
> CALL -151
* 1000G WILL START THE PROGRAM.
DID IT DO WHAT YOU THOUGHT IT WOULD DO? DO A LIST OF THE PROGRAM:
* 1000L
DOES IT LOOK THE SAME AS WHEN YOU TYPED IT IN? WHAT IS DIFFERENT?
MEMORY LOCATIONS $1001 AND $1003 HAVE BEEN CHANGED BY THE PROGRAM.
THIS IS A PROGRAM THAT CHANGES ITSELF AS IT RUNS!
WE WILL GET INTO OTHER EXAMPLES WHERE THIS IS HELPFUL AS THESE
LESSIONS CONTINUE.
LESSON 4...COMPUTER NUMBERS
BINARY, HEXIDECIMAL AND DECIMAL ARE NUMBER SYSTEMS HAVING DIFFERENT
BASES. ALL ARE USED IN DEALING WITH COMPUTERS. THE FIRST TWO, BINARY
AND HEXADECIMAL, MAY BE NEW TO SOME PEOPLE.
LET'S TALK ABOUT DECIMAL NUMBERS FIRST.
129 IS ONE HUNDRED TWENTY NINE
129 = 1*100 + 2*10 + 9*1
23 IS TWENTY THREE
23 = 2*10 + 3*1
WE KNOW THAT DECIMAL NUMBERS ARE POWERS OF TEN.
10000 1000 100 10 1
EACH ONE IS 10 TIMES THE ONE BEFORE IT.
1200 IS TWELVE HUNDRED
1200 = 1*1000 + 2*100 + 0*10 + 0*1
IN BINARY NUMBERS THE ONLY SYMBOLS WHICH ARE USED ARE 0 AND 1.
COUNTING IN BINARY (AS SHOWN FROM RIGHT TO LEFT) IS:
2048 1024 512 256 128 64 32 16 8 4 2 1
WHERE WE CAN SEE THAT EACH NUMBER IS 2 TIMES THE ONE BEFORE (GOING
RIGHT TO LEFT).
3 = 1*2 + 1*1
9 = 1*8 + 0*4 + 0*2 + 1*1
16 = 1*16 + 0*8 + 0*4 + 0*2 + 0*1
THE DECIMAL NUMBER 3 IS 11 IN BINARY. OR ANOTHER WAY, 3(BASE 10)= 11
(BASE 2)
9 (BASE 10) = 1001 (BASE 2). THE DECIMAL NUMBER 9 EQUALS THE BINARY
NUMBER 1001.
IF YOU HAVE BEEN FOLLOWING THIS, DO YOU KNOW THE ANSWER TO
101 (BASE 2) = ?????? (BASE 10)
WHAT HAVE WE SEEN BEFORE? EACH ONE IS TWICE THE ONE BEFORE....
16 8 4 2 1
SO THAT
101 STANDS FOR 1*4 + 0*2 + 1*1 IN DECIMAL OR 5.
YOU MIGHT BE WONDER WHY YOU WOULD WANT TO KNOW THIS. YOU DO NOT NEED
TO KNOW THIS, BUT IT CERTAINLY HELPS.
THE 6502 PROCESSOR HAS WHAT IS CALLED A STATUS REGISTER, "P". MOST OF
THE 6502 CPU INSTRUCTIONS AFFECT THE STATUS REGISTER P. FOR EXAMPLE,
IF WE HAD JUST EXECUTED THE INSTRUCTION
LDA #$00
(LOAD THE ACCUMULATOR IMMEDIATELY WITH THE HEXIDECIMAL NUMBER 00), THE
P REGISTER WOULD CHANGE TO REFLECT THE ZERO. BIT 1 WOULD BE SET (EQUAL
TO ONE). THE P REGISTER MIGHT BE 2 (BASE 10) OR 00000010 (BASE 2).
WE WILL EXAMINE THIS MORE AS WE CONTINUE, SO IF YOU DO NOT FEEL
COMFORTABLE AT THIS POINT, DON'T FEEL LEFT OUT.
LESSON 5 : THE 6502 PROCESSOR
LET'S NOW EXAMINE DIFFERENT PARTS OF THE ANATOMY OF THE 6502
MICROPROCESSOR. WE WILL TALK ABOUT THE ACCUMUATOR, INDEX REGISTER X,
INDEX REGISTER Y, PROGRAM COUNTER, STACK POINTER, AND THE PROCESSOR
STATUS REGISTER P.
IF WE WERE TO TALK ABOUT THE APPLE II AS A LARGE POSTOFFICE, THEN THE
ADDRESS OF A MEMORY LOCATION WOULD BE LIKE THE NUMBER OF A POSTOFFICE
BOX. FOR EXAMPLE, WE SAY THAT $C000 IS THE ADDRESS OF THE MEMORY
LOCATION THAT IS CHANGED BY THE KEYBOARD. ANOTHER EXAMPLE IS THAT $400
IS THE ADDRESS OF THE FIRST BYTE OF PAGE ONE OF THE LOW-RES SCREEN, AT
THE TOP LEFT CORNER OF THE SCREEN.
IN A POSTOFFICE THERE ARE SORTING BINS OR BOXES WHICH SERVE AS
TEMPORARY PLACES TO KEEP THINGS.
LIKEWISE IN THE APPLE, THE ACCUMULATOR, INDEX REGISTER X AND INDEX
REGISTER Y CAN BE COMPARED TO THESE TEMPORARY PLACES TO KEEP LETTERS.
WE CAN PUT NUMBERS IN THEM AND TAKE NUMBERS OUT OF THEM. ONE
DIFFERENCE IS THAT WHEN WE TAKE WHAT IS IN THEM AND STORE THAT NUMBER
ELSEWHERE, THAT ORIGINAL NUMBER IS STILL LEFT IN THE REGISTER. (FOR
EXAMPLE, WE CAN TAKE THE NUMBER IN THE ACCUMULATOR AND STORE IT
ELSEWHERE, AND IT IS STILL PRESENT IN THE ACCUMULATOR.)
THE PROCESSOR STATUS REGISTER P IS RATHER LIKE A BLACKBOARD WHERE WE
MIGHT MAKE A CHECK MARK IF THE LETTER WE PICKED UP WAS AN AIRMAIL
LETTER, WHILE WE WOULD REMOVE THAT CHECK MARK IF THE NEXT LETTER WE
PICK UP IS NOT AN AIRMAIL LETTER.
SOME EXAMPLES OF HOW TO USE THE MOST IMPORTANT OF THE REGISTERS IN THE
6502, THE ACCUMULATOR, ARE AS FOLLOWS:
STA $05 STORE WHAT IS IN THE
ACCUMULATOR IN MEMORY
LOCATION $05
STA $0400 STORE WHAT IS IN THE
ACCUMULATOR IN MEMORY
LOCATION $0400
LDA $0568 LOAD THE ACCUMULATOR WITH
WHAT IS IN MEMORY
LOCATION $0568
LESSON 6 : KEYBOARD
ONE OF THE THINGS YOU NEED TO KNOW IF YOU ARE GOING TO PRINT MESSAGES
ON THE SCREEN IS THE LIST OF ASCII CODES FOR THE DIFFERENT LETTERS.
DID YOU KNOW THE ASCII CODE FOR "1" IS $B1 (HEXADECIMAL)? ($B1 = 11*16
+ 1*1 = 177 ).
THIS INFORMATION CAN BE FOUND ON PAGE SEVEN OF THE APPLE II REFERENCE
MANUAL. LOCATED THERE IS TABLE 2, WHICH IS A LIST OF THE APPLE II
KEYBOARD CHARACTERS AND THEIR ASSOCIATED ASCII CODES.
LET'S WRITE A SHORT MACHINE CODE PROGRAM TO CHECK THE TABLE. TO DO
THAT, WHAT THINGS DO WE NEED TO KNOW?
1) THE MEMORY LOCATION OF THE KEYBOARD
2) A WAY TO PRINT TO THE SCREEN
$C000 IS THE MEMORY LOCATION INSIDE THE APPLE II WHICH HOLDS THE CODE
OF THE LAST KEY PRESSED.
$FDF0 IS A ROUTINE IN THE MONITOR ROM THAT WILL PRINT TO THE SCREEN.
$FDDA IS A ROUTINE IN THE MONITOR ROM THAT WILL PRINT HEXADECIMAL
NUMBERS TO THE SCREEN.
NOW LETS'S WRITE A PROGRAM!
CALL-151 (TO GO INTO MONITOR)
*F666G (USE THE MINI-ASSEMBLER)
!1000:LDA $C000 (LOAD THE ACCUMULATOR WITH WHAT IS IN THE KEYBOARD)
JSR $FDF0 (JUMP TO THE SUBROUTINE AT $FDF0, USING THE MACHINE
CODE PROGRAM THAT IS IN THE MONITOR ROM)
JMP $1000 (JUMP TO THE START AND DO IT AGAIN)
NOW RUN THE ABOVE PROGRAM BY EXITING THE MINI-ASSEMBLER AND THEN GOING
TO LOCATION $1000:
! $1000G
DID THE SCREEN FILL WITH CHARACTERS? DID IT CHANGE IF YOU PRESSED ANY
KEY?
LET'S MAKE THE PROGRAM A LITTLE BETTER.
GET INTO THE MINI-ASSEMBLER
*F666G
!1000:LDA $C000 LOAD THE ACC WITH KEYBOARD DATA
BPL $1000 GOTO $1000 IF THE KEYBOARD DATA IS POSITIVE.
WHEN A KEY IS PRESSED THE HIGH-BIT IN $C000
WILL BE "1"...WHICH MAKES IT A NEGATIVE
NUMBER TO THE 6502 MICROPROCESSOR CHIP
INSIDE YOUR APPLE.
JSR $FDF0 USE THE MONITOR ROUTINE TO PRINT TO THE SCREEN
LDA $C010 CLEAR THE KEYBOARD STROBE. THIS MAKES
THE HIGH-BIT IN $C000 ="0"..WHICH
MAKES IT A POSITIVE NUMBER TO YOUR APPLE.
JMP $1000 DO IT AGAIN
! $1000G WILL RUN THE PROGRAM
NOW, IF THINGS ARE RIGHT, EVERYTIME YOU PRESS A KEY YOU SHOULD SEE IT
ON THE SCREEN.
LET'S MAKE OUR PROGRAM A LITTLE LONGER.
*F666G GOTO THE MINI-ASSEMBER
!1000: LDA $C000
BPL $1000
JSR $FDF0
LDA #$A0 THIS IS A BLANK " "
JSR $FDF0 PRINT IT ON SCREEN
LDA $C010
JMP $1000
RUN THAT BY GOING TO $1000.
! $1000G
NOW, A PROGRAM THAT IS EVEN LONGER:
*F666G !1000:LDA $C000
BPL $1000
JSR $FDF0
LDA #$A0
JSR $FDF0
LDA $C000
JSR $FDDA PRINT HEXIDECIMAL NUMBER
LDA $C010
JMP $1000
NOW, WHEN YOU RUN THIS PROGRAM, YOU SHOULD SEE ALL THE VALUES IN THE
TABLE ON PAGE 7 IN YOUR APPLE II REFERENCE MANUAL.
MAYBE, A COUPLE WORDS OF EXPLANATION ARE NEEDED.
JSR $FDF0 TELLS THE APPLE TO JUMP TO THE SUBROUTINE LOCATED AT $FDF0
AFTER SAVING THE RETURN ADDRESS, AND EXECUTE THE MACHINE CODE LOCATED
THERE.
THE PROGRAM JUMPS TO LOCATION $FDF0 AND DOES THE INSTRUCTION AT THAT
LOCATION. THIS IS A PROGRAM ALREADY IN EXISTANCE WHICH WE WILL USE TO
MAKE OUR PROGRAM SHORTER.
LESSON 7 : INDEXED ADDRESSING
LET'S FIND AN EXAMPLE OF SOMETHING WE KNOW ABOUT IN ORDER TO DESCRIBE
THIS FORM OF ADDRESSING.
ALL OF US IN GIVING DIRECTIONS TO SOMEONE HAS SAID SOMETHING LIKE
"IT'S THE THIRD HOUSE ON THE LEFT AFTER YOU PASS THE STOPLIGHT".
INDEXED ADDRESSING IS THE SAME TYPE THING.
THE INDEX WOULD BE LIKE "IT'S THE THIRD HOUSE ON THE LEFT ". THE BASE
ADDRESS IS LIKE "AFTER YOU PASSED THE STOPLIGHT".
LDA $4000,X
LOAD THE ACCUMULATOR REGISTER (LDA) WITH WHAT IS IN THE MEMORY
LOCATION X ADDRESSES AFTER THE ADDRESS $4000.
IF X=$05, THEN WE WOULD BE TALKING ABOUT ADDRESS $4000+$05 OR $4005.
THE INDEX IS THE REGISTER X. THE BASE ADDRESS (IN THIS CASE ) IS
$4000.
WHY?
WHY DO YOU WANT TO KNOW WHAT THIS DOES?
EXAMPLE:
SUPPOSE WE HAD 5 NUMBERS IN MEMORY LOCATIONS $3500, $3501, $3502,
$3503 AND $3504... AND THAT WE WANT TO MOVE THEM TO $0408, $0409,
$040A, $040B AND $040C.
WE COULD DO IT LIKE THIS:
LDA $3500 LOAD THE A-REG WITH WHAT IS IN $3500
STA $0408 STORE WHAT IS IN REG-A AT MEMORY
LOCATION $0408
LDA $3501 LOAD THE ACCUMULATOR WITH WHAT IS IN $3501
STA $0409 STORE THE ACC IN MEMORY LOCATION $0409
LDA $3502 LOAD ACCUMULATOR
STA $040A STORE ACC IN $040A
LDA $3503 LOAD ACCUMULATOR
STA $040B STORE ACC IN $040B
LDA $3504 LOAD THE ACCUMULATOR WITH WHAT IS IN
MEMORY LOCATION $3504
STA $040C STORE THE ACCUMULATOR IN MEMORY LOCATION
$040C.
AT THIS POINT YOU MAY WANT TO GO TO THE MINI-ASSEMBER AND ENTER THE
ABOVE PROGRAM INTO MEMORY AT $1000 AND PUT SOME NUMBERS IN
$3500...$3504 AND SEE IF THE NUMBERS ARE MOVED.
DID THE SCREEN CHANGE WHEN YOU RAN THE PROGRAM? GOOD...IF IT DID.
RUN IT AGAIN WITH $C8 IN $3500, $C5 IN $3501, $CC IN $3502, $3503, AND
$CF IN $3504.
DID "HELLO" SHOW UP ON THE SCREEN?
LET'S DO THE SAME PROGRAM...MOVE $3500...$3504 TO $0408...$040C. USE
THE INDEX ADDRESSING INSTRUCTION.
LDX #$00 SET THE X-REGISTER EQUAL TO ZERO...OR
...LOAD X-REGISTER IMMEDIATELY WITH $00.
LDA $3500,X LOAD ACC WITH WHAT IS X BYTES
PAST ADDRESS $3500.
LDA ( $3500+$00)
LDA $3500
STA $0408,X STORE THE ACC AT X MEMORY LOCATIONS
PAST $0408...STORE THE ACCUMULATOR
AT $0408 INDEXED BY THE X-REGISTER.
INX INCREMENT THE X REGISTER BY ONE.
SINCE IT WAS ZERO, IT IS NOW $0+$1=$1.
LDA $3500,X LOAD THE ACC WITH WHAT IS THE MEMORY
LOCATION X BYTES AFTER $3500... OR
SINCE X=$01...
LOAD THE ACC WITH WHAT IS AT $3501
STA $0408,X STORE THE ACC AT $0408 INDEXED BY
THE X-REGISTER...
INX X = $01 +$01 = $02
LDA $3500,X
STA $0408,X STA $0408+$02
STA $040A
INX X=$02 + $01 = $03
LDA $3500,X $3500+$03=$3503
STA $0408,X $0408+$03=$040B
INX
LDA $3500,X
STA $0408,X
THIS PROGRAM WILL DO THE SAME AS THE PROGRAM WE LOOKED AT BEFORE.
LETS LOOK AT IT ONCE AGAIN.
LDX #$00
LDA $3500,X
STA $0408,X
INX
LDA $3500,X
STA $0408,X
INX
LDA $3500,X
STA $0408,X
INX
LDA $3500,X
STA $0408,X
INX
LDA $3500,X
STA $0408,X
NOTICE THAT WE USED "LDA $3500,X"
AND "STA $0408,X" 5 TIMES ...ONCE EACH TIME WE WANTED
TO MOVE A NUMBER.
LETS WRITE ONE MORE PROGRAM TO DO THE SAME THING. (THIS ONE WILL
REQUIRE AN ASSEMBLER.)
LDX #$00
LINE2 LDA $3500,X
STA $0408,X
INX
CPX #$05
BNE LINE2
NOW THE PROGRAM IS SHORTER.
WE ADDED TWO NEW INSTRUCTIONS...
CPX #$05
BNE LINE2
CPX #$05 COMPAGE THE X-REGISTER WITH THE NUMBER $05
BNE LINE2 IF THE X-REGISTER DOES NOT EQUAL $05, THEN GOTO LINE2.
IF WE WANTED TO MOVE $53 NUMBERS, OUR LATEST PROGRAM IS EASIER TO
WRITE...
LDX #$00 LINE2 LDA $3500,X
STA $0408,X
CPX #$53
BNE LINE2
AND I LIKE TO DO THINGS THE EASY WAY. THIS WAS ONE EXAMPLE OF HOW TO
USE INDEXED ADDRESSING, AND OBVIOUSLY THERE ARE MANY OTHER WAYS TO USE
IT.
LESSON 8: THE STACK
THE "STACK" CAN BE COMPARED TO A NOTE PAD USED TO WRITE THINGS DOWN
ON... NOTES THAT TELLS US THINGS TO DO.
IF WE HAVE FOUR OR FIVE THINGS TO DO IN ONE DAY WE MIGHT WRITE THEM
DOWN IN OUR NOTE PAD.
IF THE APPLE ][ HAS ONE OR MORE SUBROUTINES TO DO, IT WRITES DOWN IN
THE "STACK" WHAT TO DO.
IT IS SORT OF LIKE WRITING A NOTE ON A PIECE OF PAPER AND THEN PLACING
THE NOTE ON A SPINDLE. LATER, WHEN WE THING OF SOMETHING ELSE WE
SHOULD DO WE PUT ANOTHER NOTE ON THE SPINDLE. THEN, WHEN WE GET TIME
TO DO THINGS, WE TAKE THE TOP NOTE OFF THE SPINDLE AND DO IT... THEN
THE NEXT NOTE OFF THE SPINDLE ...
FIRST ON ------- LAST OFF
SUPPOSE, FOR AN EXAMPLE, OUR STACK LOOKED LIKE :
01FF C1
01FE C8
01FD 23
<-- STACK POINTER
NOTE: THE STACK POINTER POINTS TO THE NEXT AVAILABLE SPACE.
IF OUR PROGRAM LOOKED LIKE:
C11A: A9 8D LDA #$89
C11C: 20 58 FF JSR $FF58
C11F: BA TSX
WHEN THE COMPUTER GOT TO THE JUMP TO SUBROUTINE (JSR) AT $FF58, IT
WOULD PUT THE HIGH BYTE OF THE ADDRESS OF THE LAST PART OF THE JSR
INSTRUCTION ON THE STACK FIRST
01FF C1
01FE C8
01FD 23
01FC C1
<-- STACK POINTER AND THEN THEN LOW BYTE
01FF C1
01FE C8
01FD 23
01FC C1
01FB 1E
<-- STACK POINTER
ON THE STACK. NOTICE THAT THE ADDRESS $C11E IS ON THE BOTTOM OF THE
STACK... THIS IS THE ADDRESS OF THE LAST PART OF THE JSR $FF58
INSTRUCTION....
NOW THE COMPUTER WOULD GO TO THE SUBROUTINE AT $FF58, DO WHAT IT IS
TOLD TO DO, AND WHEN IT COMES ACROSS A RETURN FROM SUBROUTINE (RTS)
INSTRUCTION, IT WILL GET THE LOW BYTE $1E FROM THE BOTTOM OF THE STACK
$01FB AND THEN IT WILL INCREMENT THE STACK POINTER AND GET THE HIGH
BYTE $C1 OFF THE STACK $01FC.
IT WILL THEN HAVE THE ADDRESS $C11E INTERNALLY TO THE CPU AND WILL
PLACE THEM IN THE PROGRAM COUNTER, ADD ONE
$C11E +$01 = $C11F
AND THE GOTO THAT ADDRESS TO CONTINUE DOING INSTRUCTIONS....
PLEASE NOTICE THAT $C11F IS THE ADDRESS ON THE INSTRUCTION THAT WAS
JUST AFTER THE JUMP TO SUBROUTINE INSTRUCTION (JSR $FF58).
Reference in New Issue View Git Blame Copy Permalink