About the Datalink
What is it?
Download Protocol
Display Segments
Memory Map
150 vs 150s

Wristapp Programming
Creating Wristapps
Wristapp Format
The State Table
Wristapp Routines

Wristapp Programming
1 - Hello World
2 - Getting Input
3 - Better Input
[This Page] 4 - Showing Selection
5 - PassWord
6 - Day Find
7 - Playing with Sound
8 - Using Callbacks
9 - Hex Dump
10 - EEPROM Dumper
11 - Spend Watch
12 - Sound Schemes
13 - Random Numbers
14 - Hourly Chimes
15 - Lottery Picker

Sound Schemes
Sound Hardware
Sound Scheme Format

Home Send Mail

Showing Selection - Blink routines

We can make our update progam a bit smarter and more obvious to the user by blinking the digit when it is available to be changed.  Like the START_UPDATEP routine, there is an equivalent START_BLINKP routine which handles blinking the display for you.  I call this routine FLASH since it is not possible to put a K on the top two lines of the display :-).

;Name: Flash

;Version: FLASH

;Description: by John A. Toebes, VIII

;This is a simple number update/flash program


;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 1 indicates that we need to clear the display first


CURVAL  EQU   $62  	; The current value we are displaying


; (2) System entry point vectors


START   EQU     *

L0110:  jmp     MAIN	; The main entry point - WRIST_MAIN

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



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



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



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



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


L0123:  jmp     HANDLE_STATE0

        db      STATETAB-STATETAB


; (3) Program strings

S6_FLASH:       timex6  "FLASH "

S6_SAMPLE:      timex6  "SAMPLE"


; (4) State Table



        db      0

        db      EVT_ENTER,TIM_2_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_MODE,TIM_ONCE,$FF           ; Mode button

        db      EVT_DNANY4,TIM_ONCE,0           ; NEXT, PREV, SET, MODE button pressed

        db      EVT_UPANY4,TIM_ONCE,0           ; NEXT, PREV, SET, MODE button released

        db      EVT_END


; (5) State Table 0 Handler

; This is called to process the state events.

; We see ENTER, TIMER2, RESUME, DNANY4 and UPANY4 events



        bset    1,APP_FLAGS	                  ; Indicate that we can be suspended

        lda     BTNSTATE                        ; Get the event

        cmp     #EVT_DNANY4                     ; Did they press a button?

        bne     CHKENTER                        ; No, pass on to see what else there might be

        lda     BTN_PRESSED                     ; Let's see what the button they pressed was

        cmp     #EVT_PREV                       ; How about the PREV button

        beq     DO_PREV                         ; handle it

        cmp     #EVT_NEXT                       ; Maybe the NEXT button?

        beq     DO_NEXT                         ; Deal with it!

        cmp     #EVT_SET                        ; Perhaps the SET button

        beq     DO_SET                          ; If so, handle it

        ; In reality, we can't reach here since we handled all three buttons

        ; in the above code (the MODE button is handled before we get here and the

        ; GLOW button doesn't send in an event for this).  We can just fall through

        ; and take whatever we get from it.


        cmp     #EVT_ENTER                      ; Is this our initial entry?

        bne     REFRESH


; This is the initial event for starting us



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

        jsr     CLEARSYM                        ; Clear the display

        lda     #S6_FLASH-START

        jsr     PUT6TOP

        lda     #S6_SAMPLE-START

        jsr     PUT6MID

        lda     #SYS8_MODE

        jmp     PUTMSGBOT


; (6) Our real working code...


        bset    0,SYSFLAGS      ; Mark our update direction as up

        bra     DO_UPD


        bclr    0,SYSFLAGS      ; Mark our update direction as down



        sta     UPDATE_MIN      ; Our low end is 0

        lda     #99

        sta     UPDATE_MAX      ; and the high end is 99 (the max since this is a 2 digit value)

        ldx     #CURVAL         ; Point to our value to be updated

        lda     #UPD_MID34      ; Request updating in the middle of the display

        jsr     START_UPDATEP   ; And prepare the update routine

        bset    4,BTNFLAGS      ; Mark that the update is now pending

        bclr    1,FLAGBYTE

        lda     #SYS8_SET_MODE

        jmp     PUTMSGBOT


        clr     CURVAL          ; When they hit the set button, we just clear to zero


        brset   1,FLAGBYTE,NOCLEAR ; Do we need to clear the display first?


        jsr     CLEARALL        ; Yes, clear everything before we start

        bset    1,FLAGBYTE      ; And remember that we have already done that


        bclr    7,BTNFLAGS      ; Turn off any update routine that might be pending

        ldx     #CURVAL

        lda     #BLINK_MID34

        jsr     START_BLINKP

        bset    2,BTNFLAGS      ; Mark a blink routine as pending



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



        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


This is code is basically identical to the Update sample with only a couple of minor changes.

  1. Program specific constants - No Change. 
  2. System entry point vectors - We have nothing special this time..
  3. Program strings - Gee, we changed the strings.
  4. State Table(s) - We get to use exactly the same state table.  See The State Table for a more complete explaination of this.
  5. State Table Handler(s) - Since the state table is the same, the state handling is the same.
  6. Program Specific Code - All we had to do different here was to call START_BLINKP and then set 2,BTNFLAGS to notify the system that we want the blink routine to run.  The blink routine will automatically handle putting up the number for us.
  7. Main Initialization routine - No changes here either. This is called once when the wristapp is first loaded.  We need to make sure that we set the appropriate bits in WRISTAPP_FLAGS.