LEX    'REPEAT'
        ID     #71
        MSG    0
        POLL   POLHND

        ENTRY  REPEAT
        CHAR   #D
        KEY    'REPEAT'
        TOKEN  28

EXPEXC  EQU    #0F186
SLEEP   EQU    #006C2
RNDAHX  EQU    #136CB
IVAERR  EQU    #0E920
RESERV  EQU    #2F986
MPY     EQU    #0ECBB
CKSREQ  EQU    #00721
FIXDC   EQU    #05493
FIXP    EQU    #02A6E
POPBUF  EQU    #010EE
NXTSTM  EQU    #08A48
SFLAGS  EQU    #135FA
SFLAGC  EQU    #13601
SFLAG?  EQU    #1364C
USRSTA  EQU    #01B80
BLDDSP  EQU    #01898
SETTMO  EQU    #13158
ALMSRV  EQU    #1257D
R<RSTK  EQU    #014DD
RSTK<R  EQU    #014A8
DEBNCE  EQU    #00CF7
KEYBUF  EQU    #2F444
IDIVA   EQU    #0EC6E
KCOLO   EQU    #2F46F
TIMER1  EQU    #2E3F8
KEYPTR  EQU    #2F443
FORSTK  EQU    #2F59E
DELAYp  EQU    #02AC6
fTMOUT  EQU    #3
flRPTD  EQU    #C5
k#OFF   EQU    #63
pWTKY   EQU    #1C

        ENDTXT

**************************************************
* Routine d'interception de poll
************************************************
POLHND
        LC(2)  =pWTKY
        ?B=C   B        S'agit-il du poll envoyÅ
         *              lorsque le 71 est en mode
         *              d'Ådition ?
        GOYES  KEYR     Oui; il faut scruter le
         *              clavier
        RTNSXM          Non; le poll envoyÅ ne
         *              nous concerne pas

**************************************************
* Routine KEYR
* Cette routine scrute le clavier: elle attend que
* l'on appuie sur une touche, puis place le code
* de la touche sur laquelle on a appuyÅ dans R0(B)
* KEYR boucle indÅfiniment sur elle-mÁme si l'on
* n'appuie sur aucune touche.
**************************************************
KEYR
        P=     4        Sauvegarde en RAM les 5
         *              derniers adresses placÅes
         *              dans la pile de 
        GOSBVL =R<RSTK  Retour (RSTK)
        GOSUB  RPTKY    L'action d'une touche
         *              doit-elle se rÅpÅter ?
        GOC    DEFKY    Oui; on retourne le code
         *              de cette touche a la
         *              routine qui a Åmis le pol
        GOSBVL =USRSTA  Construit l'affichage
         *              pour qu'il soit la
         *              rÅplique du buffer d'Åcran
        GOSBVL =BLDDSP
        GOSBVL =SETTMO  Autorise la mise
         *              hors-tension du 71 au bout
         *              de 10' si pendant ce temps
         *               Aucune touche n'a ÅtÅ
         *              pressÅe

**************************************************
* DÅbut de la boucle infinie
* Elle est du type:
*    0 0 DO 
*        TRY-TO-SLEEP
*        KEY? IF LEAVE THEN
*        TIMED-OUT IF LEAVE THEN
*    LOOP
**************************************************
KEYR10  GOSBVL =SLEEP   Place le 71 dans un Åtat
         *              de faible consommation
         *              d'Ånergie. Ne retourne 
         *              Que lorsqu'une touche a
         *              ÅtÅ enfoncÅe ou lorsqu'une
         *              alarme vient È terme
        GOC    KEYR80   Nous sommes dans ce
         *              dernier cas si carry est
         *              armÅ
        GOSBVL =POPBUF  et dans le 1er si elle
         *              est dÅsarmÅe
DEFKY   C=B    A        Place le code de la
         *              touche en C(B)
DEFKY+  R0=C            puis en R0
        P=     4        Restaurons les 5 adresses
         *              prÅcÅdemment conservÅes en
         *              RAM
        GOSBVL =RSTK<R
        XM=0            et indiquons que le
         *              pol-process doit se
         *              terminer
        RTNCC

KEYR80  GOSUB  USRREQ   VÅrifie qu'aucun
         *              pÅriphÅrique n'a besoin
         *              d'aide
        GOSBVL =ALMSRV  VÅrifie qu'aucune alarme
         *              n'est È terme
        ?ST=0  =fTMOUT  10' sans activitÅ ne se
         *              sont-elles pas ÅcoulÅes ?
        GOYES  KEYR10   Non; essayons de nouveau
         *              de nous endormir
        LC(2)  =k#OFF   Oui; faisons comme si
         *              quelqu'un avait appuyÅ sur
         *              la touche OFF (f ON)
        GONC   DEFKY+   (B.E.T.)

**************************************************
* Routine utilisÅe par KEYR et RPTKY
**************************************************
USRREQ  GOSBVL =USRSTA
        GOVLNG =CKSREQ

**************************************************
* RPTKY est une routine HP. Je n'en ai modifiÅ que
* le dÅbut. Seule la partie modifiÅe sera
* commentÅe. RÅfÅrez-vous aux IDS 3 pour la partie
* non commentÅe.
*
* Algorithme simplifiÅ:
*  Si une touche commence seulement È rÅpÅter son 
*            son action (flRPTD abaissÅ)
*    alors on attend un temps T avant que cette
*            cette action ne se rÅpÉte
*    puis on arme flRPTD
*  Si la touche a dÅjÈ rÅpÅtÅ son action
*    on n'attend pas avant de rÅpÅter son action
*  Si l'on appuie sur une nouvelle touche
*    alors on dÅsarme flRPTD
**************************************************
RPTKY
        LC(2)  =flRPTD
        GOSBVL =SFLAG?  L'action de la touche
         *              s'est-elle dÅjÈ rÅpÅtÅe ?
        LCHEX  700000
        GOC    RPTK10   Oui; on n'attends pas
         *              avant de rÅpÅter de
         *              nouveau celle-ci
        R0=C            Non; on attend un temps T
         *              avant de rÅpÅter la-dÑte
         *              action
        A=0    W        Ce temps est calculÅ È
         *              partir d'un paramÉtre P
         *              dÅfini par l'utilisateur
        C=0    W         T=P*15 (T est exprimÅ en
         *              ticks; t=T/512 donne ce
         *              temps en secondes)
        D0=(5)  (=RESERV)+3 En fait on a stockÅ
         *              le complÅment È 15 de P
        C=DAT0 P
        C=-C-1 P        Il faut donc prendre le
         *              complÅment È 15 du nombre
         *              stockÅ
        A=A-1  P        Puis le multiplier par 15
        GOSBVL MPY
        C=R0            Enfin on place le
         *              rÅsultat dans C(5-0) sous
         *              la forme:
        C=A    B          70000T
RPTK10  GOSUB  WRTTM1   La routine ci-dessous est
         *              commentÅe dans les IDS 3
        LC(2)  =flRPTD
        GOSBVL =SFLAGS
RPTK20  P=     8
        GOSBVL =DEBNCE
        D1=(5) (=KEYBUF)+2*14
        A=0    A
        A=DAT1 B
        A=A-1  A
        C=0    A
        LC(2)  14
        GOSBVL =IDIVA
        P=     0
        LC(5)  =KCOLO
        C=C-B  A
        D1=C
        C=DAT1 XS
        LCHEX  3
        A=A&C  P
RPTK30  A=A-1  P
        GOC    RPTK40
        C=C+C  XS
        GOTO   RPTK30
RPTK40  C=C+C  XS
        GOC    RPTK45
RPTKCC  LC(2)  =flRPTD
        GOSBVL =SFLAGC
TMRRST  C=0    W
        C=C+1  XS
        GOTO   WRTTM1
RPTK45  D0=(5) (=TIMER1)+5
        D1=(5) =KEYPTR
        A=DAT0 P
        LCHEX  7
        ?A=C   P
        GOYES  RPTK47
        GOSUB  TMRRST
        D0=(5) (=KEYBUF)+2*14
        A=DAT1 XS
        ?A#0   XS
        GOYES  RPTKCC
        A=DAT0 B
        B=0    A
        B=A    B
        RTNSC
RPTK47  A=DAT1 XS
        ?A#0   XS
        GOYES  RPTKCC
        GOSUB  USRREQ
        GOTO   RPTK20

WRTTM1
        D0=(5) =TIMER1
        P=     5
        DAT0=C 6
        A=DAT0 6
        ?A=C   WP
        GOYES  WRTTMX
        DAT0=C 6
WRTTMX  P=     0
        RTNCC

**************************************************
* REPEAT stocke le paramÉtre P dÅfini par
* l'utilisateur sous la forme de son complÅment È 
* 15  ( complÅment(P)=15-P ). Ceci est dà au fait
* que lorsque la mÅmoire est rÅinitialisÅe, la
* valeur par dÅfaut de P est zÅro (0). Or il est
* difficile d'utiliser le clavier lorsque l'option
* REPEAT 0 est active. Si par contre on stocke le
* stocke le complÅment È 15 de P, la valeur par 
* dÅfaut lors d'une rÅinitialisation ne sera plus
* zÅro (0) mais quinze (15-0).
**************************************************
        REL(5) fixdc
        REL(5) fixp     REPEAT (Exp. num.)
REPEAT  GOSBVL =EXPEXC  Evalue l'expression
         *              suivant l'ordre REPEAT
        GOSBVL =RNDAHX  convers. en hex dans A(A)
        GONC   ivaerr   
        C=0    A        erreur si >15
        C=C-1  P
        ?C>=A  A
        GOYES  REP10
ivaerr  GOVLNG =IVAERR
REP10   A=-A-1 P        Stocke dans la "Reserved
         *              Ram" (MÅmoire rÅservÅe par
         *              HP pour une future 
        D0=(5) (=RESERV)+3         utilisation) le
         *              complÅment È 15 de P
        DAT0=A P
        GOVLNG =NXTSTM

**************************************************
* NOTE:
* Toutes les routines utilisÅes par REPEAT sont
* supportÅes par HP. NÅanmoins, cet ordre utilise
* aussi une partie de la "Reserved Ram" qui ne lui
* est pas allouÅe en propre. En consÅquence, des 
* conflits peuvent Åventuellement avoir lieu entre
* le Lex REPEAT et d'autres Lex. C'est pourquoi
* nous vous communiquerons en temps utile
* l'adresse de la partie de la "Reserved Ram" qui 
* nous sera allouÅe.
**************************************************

fixdc   GOVLNG =FIXDC
fixp    GOVLNG =FIXP

        END