Getting Input

A program which just does output and really takes no input is not very useful.  The first stage in making a program more useful is to figure out how to allow the user to enter a value.  With this first numbers program, we allow you to enter a number by pressing the PREV/NEXT key to advance it by one each time you press the key.   This allows us to see how basic input works and a couple of the formatting/display routines.

;Name: Numbers

;Version: NUMBER

;Description: This is a simple number count program

;by John A. Toebes, VIII

;

;TIP:  Download your watch faster:  Download a WristApp once, then do not send it again.  It stays in the watch!

;HelpFile: watchapp.hlp

;HelpTopic: 106

            INCLUDE "WRISTAPP.I"

;

; (1) Program specific constants

;

FLAGBYTE	EQU  	$61

;   Bit 0 indicates that we want to show the segments instead of the message

;

CURVAL      EQU   $62  	; The current value we are displaying

START	    	EQU   *

;

; (2) System entry point vectors

L0110:  jmp	MAIN	; The main entry point - WRIST_MAIN

L0113:  rts             ; Called when we are suspended for any reason - WRIST_SUSPEND

        nop

      	nop

L0116:  rts             ; Called to handle any timers or time events - WRIST_DOTIC

        nop

        nop

L0119:	rts             ; Called when the COMM app starts and we have timers pending - WRIST_INCOMM

        nop

        nop

L011c:	rts             ; Called when the COMM app loads new data - WRIST_NEWDATA

        nop

        nop



L011f:	lda	STATETAB,X ; The state table get routine - WRIST_GETSTATE

        rts



L0123:  jmp HANDLE_STATE0

        db  STATETAB-STATETAB

;

; (3) Program strings

S6_NUMBER:	timex6  "NUMBER"

S6_COUNT:   timex6  "COUNT "

;

; (4) State Table

STATETAB:

        db      0

        db      EVT_ENTER,TIM2_8TIC,0 	; Initial state

        db      EVT_TIMER2,TIM_ONCE,0   ; The timer from the enter event

        db      EVT_RESUME,TIM_ONCE,0   ; Resume from a nested app

        db      EVT_DNNEXT,TIM_ONCE,0	; Next button

        db      EVT_DNPREV,TIM_ONCE,0   ; Prev button

        db      EVT_DNSET,TIM_ONCE,0    ; Set button

        db      EVT_MODE,TIM_ONCE,$FF	; Mode button

        db      EVT_END

;

; (5) State Table 0 Handler

; This is called to process the state events.  We will see ENTER, RESUME, DNNEXT, DNPREV, DNSET, and TIMER2

;

HANDLE_STATE0:

        bset	1,APP_FLAGS             ; Indicate that we can be suspended

        lda     BTNSTATE                ; Get the event

        cmp 	#EVT_DNNEXT             ; Did they press the next button?

        beq     DO_NEXT			; Yes, increment the counter

        cmp     #EVT_DNPREV             ; How about the PREV button

        beq     DO_PREV                 ; handle it

        cmp     #EVT_DNSET              ; Maybe the set button?

        beq     DO_SET                  ; Deal with it!

        cmp     #EVT_ENTER              ; Is this our initial entry?

        bne     REFRESH

;

; This is the initial event for starting us

;

DO_ENTER    

        bclr    1,FLAGBYTE              ; Indicate that we need to clear the display

        jsr     CLEARSYM			; Clear the display

        lda 	#S6_NUMBER-START

        jsr 	PUT6TOP

        lda 	#S6_COUNT-START

        jsr 	PUT6MID

        lda 	#SYS8_MODE

        jmp 	PUTMSGBOT

;

; (6) Our only real working code...

DO_NEXT

        inc     CURVAL

	lda     CURVAL

	cmp     #100

	bne     SHOWVAL

DO_SET

        clr     CURVAL

SHOWVAL

	brset   1,FLAGBYTE,NOCLEAR

REFRESH

      	jsr     CLEARALL

        bset    1,FLAGBYTE

NOCLEAR

	ldx     CURVAL

        jsr     FMTXLEAD0

	jmp     PUTMID34

DO_PREV

	lda     CURVAL

 	beq     WRAPUP

	dec     CURVAL

	bra     SHOWVAL

WRAPUP

        lda     #99

	sta     CURVAL

	bra     SHOWVAL

;

; (7) This is the main initialization routine which is called when we first get the app into memory

;

MAIN:

        lda     #$c0				; We want button beeps and to indicate that we have been loaded

        sta     WRISTAPP_FLAGS

        clr     FLAGBYTE			; start with a clean slate

        clr     CURVAL

        rts

We have the same 7 basic sections, but some of them are a little more filled out.

1. Program specific constants - We have only two basic variables.  The flagbyte and the current value. 
2. System entry point vectors - We have nothing special this time..
3. Program strings - THe strings go here for addressability.
4. State Table(s) - This really tells the watch how we want to operate and what events we want to handle.  See The State Table for a more complete explaination of this. For this, we want to see the down events for the NEXT, PREV, and SET buttons so that we can increment, decremet, or reset the counter as appropriate.  We also have coded the MODE button with the magic $FF which causes it to advance to the next app.
5. State Table Handler(s) - Here we have the typical CMP/BEQ instruction sequence to quickly determine what event happened.  Note that the EVT_ENTER event causes a timer to go off which allows us to clear the screen 8/10 second after they switch to the app.
6. Program Specific Code - The actual meat of the program.  We really only have to deal with advance/retreat/reset of the value and then displaying it after each change..
7. Main Initialization routine - This is called once when the wristapp is first loaded.  We need to make sure that we set the appropriate bits in WRISTAPP_FLAGS.

Just pressing a button for each increment can be tedious.  Learn how to make it better with: Better Input - Update