GENWiki

Premier IT Outsourcing and Support Services within the UK

User Tools

Site Tools


archive:apple:mllessons
     
     **************************************************************
     *                  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).

/data/webs/external/dokuwiki/data/pages/archive/apple/mllessons.txt · Last modified: 2019/05/17 09:32 by 127.0.0.1

Was this page helpful?-10+1

Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki