Re: A89: STron89


[Prev][Next][Index][Thread]

Re: A89: STron89




In a message dated 98-12-09 20:09:50 EST, you write:

<< WOW..  long letter :)
 I'll do some comments here, and some more in your letter...
 first...
 The thing all of this is doing, is reading the keyboard directly..
 this is done by the two memoryadresses $600018 and $60001B
 
 $60018 is used to set witch rows in the keyboard you want to check.. (check
the
 kbd89.txt on www.ticalc.org to find witch keys are in witch rows) and $60001B
is
 then used to read from the keyboard witch keys in the rows selected by
$600018
 is pressed.
 
 more comments within...
 
 S43R80@aol.com wrote:
 <cutting some crap...>
 > 
 > kbd_arrows      EQU             %111111110
 > kbd_column5     EQU             %111111101
 > kbd_column4     EQU             %111111011
 > kbd_column3     EQU             %111110111
 > kbd_column2     EQU             %111101111
 > kbd_column1     EQU             %111011111
 > kbd_exitkey     EQU             %110111111
 > 
 > dir_left        EQU             0
 > dir_up          EQU             1
 > dir_right       EQU             2
 > dir_down        EQU             3
 > 
 > _main:
 >         bsr             WaitKBD
 > 
 > Please try to reply in the most simplist terms possible...
 > What does EQU do?  and what are those bits used for?  Is it to mask
something
 > out or something...how come dir_up etc. is given equ and then a number...Is
 > that used in some kind of rom call to check if it is pressed?
 
 Theese are different keymasks...   kbd_arrows is the value you should move to
 $600018 to read the arrowkeys. (and some more keys)
 
 all the other EQU's (but the dir_xxx) are values you can get when you read
from
 $60001B..  they are quite selfexplanatoiry when they occur..  
 
 the dir_xxx's are whitch bit in $60001B is cleared when thoose keys are
pressed.
 (when kbd_arrows have been written to $600018)
 
 
 > WaitKBD:
 >         move.w  #$00,d0                                 ; set keymask to
read all keys
 >         bsr             ReadKBD
 >         cmp.b   #$ff,d0                                 ; check to see if
any key is pressed
 >         bne             WaitKBD                                 ; if so,
start over
 >         rts
 > 
 > Now how does moving 0 into d0 set a  key mask to read all keys?  How is it
 > used?
 > Now it branches to ReadKBD:
 
 His subroutine uses d0 to hold the mask to be used...
 
 > 
 > ReadKBD:
 >         move.w  d1,-(a7)
 >         move.w  d0,d1
 >         move.w  #$700,d0                    ; Disable interrupts, saving
old in mask
 > in d0
 >     trap    #1
 > 
 >         move.w  d1,($600018)                    ; set keymask
 >         nop                                                             ;
pause so TI89 has
 > time to apply the mask
 >         nop
 >         nop
 >         nop
 >         nop
 >         nop
 >         nop
 >         nop
 >         nop
 >         nop
 >         nop
 >         nop
 >         nop
 >         nop
 >         nop
 >         nop
 >         clr.w   d1
 >         move.b  ($60001b),d1                    ; get keys hit
 >         trap    #1
 >         move.w  d1,d0
 >         move.w  (a7)+,d1
 >         rts
 > 
 > Why is d1 moved onto the stack...It doesn't contain anything yet!  And
rightn
 > now d0 contains "0" and it is copied to d1...why?  Now the immediate value
700
 > in hexadecimal, right?, is moved into d0...what purpose does this serve?
How
 > does it "disable the interrupts" and why does this need to be done?  And
what
 > does trap #1 do?  I have no idea at all!...
 
 d1 is moved to the stack to not be destroyed in the subroutine..  he pop's it
of
 the stack in the end..
 The trap #1 is a "system subroutine" the purpouse of trap #1 is to mess with
the
 interrupts..  the input he does to trap #1 is doing what he has commented..
 
 > 
 > move.w  d1,($600018)
 > 
 > here d1 is copied to the memory address $600018...Why is it $600018?  what
#'s
 > can you pick from?  d1 contained 0 right...so your actually moving 0 into
that
 > mem. address, right?  And how is that setting the key mask?
 > 
 
 Explained at top.
 
 > Now nop is used for very small delays...but why did the 89 need extra time?
 
 The ti89 has some hardware to eliminate "key-bouncing" that is, if you press
the
 key once, you will only detect it once..  unfurtunately this also makes the
 keybordmask-setting to be somewhat slow..  so therefore he needs som extra
delay
 before the keybordmask works...
 
 > 
 > So now d1 is cleared right?  When you clear something what does that
 > mean...didn't d1 contain 0...isn't it already cleared?
 >         move.b  ($60001b),d1
 > now why are we moving the contents at mem. address $60001b to d1?  How
could
 > the contents have changed (it previously contained 0)?  How does that get
the
 > keys hit...Does it have something to do with the trap #1thing?
 > Now why is trap #1 executed again?
 > 
 
 explained above..
 
 > then d1 is copied to d0...why dont you just leave the contents of d1 alone?
 > 
 >         move.w  (a7)+,d1
 > 
 > I have no idea here!  I'm guessing it is updating the stack so the prog
will
 > not crash!  But how does this work?
 
 he is restoring d1 from the stack, so it would not be destroyed by the
 subroutine..
 
 > 
 > now it returns back to WaitKBD:
 > WaitKBD:
 >         move.w  #$00,d0                                 ; set keymask to
read all keys
 >         bsr             ReadKBD
 >         cmp.b   #$ff,d0                                 ; check to see if
any key is pressed
 >         bne             WaitKBD                                 ; if so,
start over
 >         rts
 > 
 > cmp does $ff minus d0 right?  How does this check if a key is pressed...I
 > understand that it branches back to WaitKbd if a the result was 0 but how
will
 > the result be 0...so if a key is pressed it will go back to ReadKbd???????
if
 > not then it will go back to _main?????????
 
 the subroutine returnes the read value from $60001B in d0..   if no keys
where
 pressed this value should be $ff..
 
 hope this helped.. 
 
 
 //Olle >>



Thanks...you really helped a lot, but one thing still confuses me:

> WaitKBD:
 >         move.w  #$00,d0                                 ; set keymask to
read all keys
 >         bsr             ReadKBD
 >         cmp.b   #$ff,d0                                 ; check to see if
any key is pressed
 >         bne             WaitKBD                                 ; if so,
start over
 >         rts
 > 

The author says "check to see if any key is pressed if so, start over"...but
wouldn't you want to exit the routine if a key was pressed instead of going
throught the whole waitkbd thing again otherwise that routine would be
useless?