Accueil Ti-Gen Foire Aux Questions Chat sur le chan #tigcc sur IRC
Liste des membres Rechercher Aide
Bienvenue Invité !   Se connecter             Mes sujets   
Administrer
0 membre(s) et 1 visiteur(s) actif(s) durant les 5 dernières minutes Utilisateurs actifs : Aucun membre + 1 visiteur
Avant de poster sur le forum, il y a des régles de bases à respecter pour une bonne entente et un respect de tous.
Veuillez lire la charte du forum.
  :: Index » Forum Ti68K » Programmation Assembleur 68K » ngetchx sans interruptions (16 réponse(s))
./POST DE DEPART (post n°0)   Marquer comme non lu.
geogeo Ecrit le: Lundi 23 août 2004 à 21:14 Déconnecté(e)    Voir le profil de geogeo Envoyer un email à geogeo Visiter le site WEB de geogeo Envoyer un message privé à geogeo  
Fondateur

Groupe: Staff de Ti-Gen
Groupe: Orage Studio

Messages: 4257
Membre n°3
Inscrit le 29 janvier 2004
Voilà, j'ai obtenu la source suivante de janjan2.
Mais je ne comprend pas pourquoi elle ne fonctionne pas. Les touches ESC, MODE... ne sont pas détectées et surtout les valeurs renvoyées sont alétaoires. :(


| Assembly Source File
| Created 23/08/2004; 18:56:23
| C prototype: unsigned short _kb_getkey (unsigned char calc asm("%d0"));

.data
.globl _kb_getkey
.even

_kb_getkey: 
     move.l     %d3,-(%a7)
     move.l     %d4,-(%a7)    
     move.b     %d0,CALCULATOR
     moveq.l  #0,%d0       |on clean d0: dans lequel sera stocké l'index
     moveq.l  #1,%d2
     lea    _kb_key_masks(%PC),%a0   |on fait pointer a0 - le tableau de masques
|detection de la calto(6 ou 7 rows suivant le modele)
     tst.b   CALCULATOR
     beq   _kb_calc92_row
     move.l   #5,_kb_numrows
     addq.l   #6,%a0
_kb_calc92_row:
|boucle pour chaque row
     move.l   _kb_numrows,%d3    |compteur de row
_kb_getkey_loop_row:
|recuperation de la row
     move.w    (%a0),(0x60001  |masque
     lsr.l     #6,%d1
     lsr.l     #6,%d1
     move.b    (0x60001B),%d1     |on recupere la row dans d1
     addq.l    #2,%a0
|boucle pour chaque col
     move.l   #7,%d4       |compteur de col
_kb_getkey_loop_col:          
     lsr.b     %d2,%d1
     bcc       _kb_getkey_lastrow   |on quitte si detection d'une touche
     add.l     %d2,%d0     |on incremente d0 (index)
     dbra      %d4,_kb_getkey_loop_col |fin de boucle col
     dbra      %d3,_kb_getkey_loop_row |fin de boucle row
|derniere rangée     
_kb_getkey_lastrow:
|;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|;; rangée 0
     move.w    0xFFFE,(0x60001   |masque du bit 0     
     lsr.w     #6,%d1
     lsr.w     #6,%d1
     move.b    (0x60001B),%d1     |on recupere la row
|;;
|;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|detection de la calto
     eor.l   %d3,%d3
     tst.b   CALCULATOR
     beq   _kb_calc92_retval
     cmp.w   #48,%d0
     bne   _kb_calc89_endarrows
|lecture des flèches
     lsr.b     %d2,%d1
     bcc       _kb_calc89_endarrows   |on quitte si detection d'une touche
     add.l     %d2,%d0     |on incremente d0 (index)
     lsr.b     %d2,%d1
     bcc       _kb_calc89_endarrows   |on quitte si detection d'une touche
     add.l     %d2,%d0     |on incremente d0 (index)
     lsr.b     %d2,%d1
     bcc       _kb_calc89_endarrows   |on quitte si detection d'une touche
     add.l     %d2,%d0     |on incremente d0 (index)
     lsr.b     %d2,%d1
     bcc       _kb_calc89_endarrows   |on quitte si detection d'une touche
|quitte avec 0 si aucune touche n'est pressée
     moveq   #0,%d0
     move.l     (%a7)+,%d4
     move.l     (%a7)+,%d3
     rts
_kb_calc89_endarrows:
|lecture des stat keys
     lsr.b    %d2,%d1
     bcc       _kb_calc89_2nd
     lsr.b     %d2,%d1
     bcc       _kb_calc89_shift
     lsr.b     %d2,%d1
     bcc       _kb_calc89_diamond
     lsr.b     %d2,%d1
     bcc       _kb_calc89_alpha
           
     lea    _kb_key_data_89_normal,%a0
     bra   _kb_return
_kb_calc89_shift:
     move.l   %d2,%d3
_kb_calc89_alpha:
     lea    _kb_key_data_89_alpha(%PC),%a0
     bra   _kb_return     
_kb_calc89_2nd:
     lea    _kb_key_data_89_2nd(%PC),%a0
     bra   _kb_return     
_kb_calc89_diamond:
     lea    _kb_key_data_89_diamond(%PC),%a0
     bra   _kb_return
_kb_calc92_retval:
|lecture des stat keys
     lsr.b     %d2,%d1
     bcc       _kb_92P_V200_2nd
     lsr.b     %d2,%d1
     bcc       _kb_92P_V200_diamond
     lsr.b     %d2,%d1
     bcc       _kb_92P_V200_shift
     lsr.b     %d2,%d1
     bcc       _kb_92P_V200_lock     
     bra   _kb_92P_V200_normal
     
_kb_92P_V200_shift:
     move.l   %d2,%d3
_kb_92P_V200_normal:               
     lea.l    _kb_key_data_92P_V200_normal(%PC),%a0
     bra   _kb_calc92_endstatus
_kb_92P_V200_2nd:
     lea.l    _kb_key_data_92P_V200_2nd(%PC),%a0
     bra   _kb_calc92_endstatus     
_kb_92P_V200_diamond:
     lea.l    _kb_key_data_92P_V200_diamond(%PC),%a0
     bra   _kb_calc92_endstatus     
_kb_92P_V200_lock:
     lea.l    _kb_key_data_92P_V200_lock(%PC),%a0
_kb_calc92_endstatus:
     cmp.w   #72,%d0
     bne   _kb_return
|lecture des flèches
     lsr.b    %d2,%d1
     bcc       _kb_return       |on quitte si detection d'une touche
     add.l     %d2,%d0       |on incremente d0 (index)
     lsr.b     %d2,%d1
     bcc       _kb_return       |on quitte si detection d'une touche
     add.l     %d2,%d0       |on incremente d0 (index)
     lsr.b     %d2,%d1
     bcc       _kb_return       |on quitte si detection d'une touche
     add.l     %d2,%d0       |on incremente d0 (index)
     lsr.b     %d2,%d1
     bcc       _kb_return       |on quitte si detection d'une touche
|quitte avec 0 si aucune touche n'est pressée
     moveq.l   #0,%d0
     move.l     (%a7)+,%d4
     move.l     (%a7)+,%d3
     rts
 
_kb_return:
     add.l   %d0,%a0
     add.l   %d0,%a0
     move.w   (%a0),%d0
     tst.b   %d3
     beq   _kb_end
     cmp.l   #97,%d0
     blt   _kb_end
     cmp.l   #122,%d0
     bgt   _kb_end
     sub.l   #32,%d0
_kb_end:
     move.l     (%a7)+,%d4
     move.l     (%a7)+,%d3     
     rts          
 
|;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|;; données
_kb_numrows:
     .long 8
|masques précalculés
_kb_key_masks:
     .word  0xFDFF,0xFEFF,0xFF7F,0xFFBF,0xFFDF,0xFFEF,0xFFF7,0xFFFB,0xFFFD
|codes de touches
_kb_key_data_92P_V200_normal:
     .word 45,13,97,113,271,48,46,173,257,136,108,111,43,266,264,0,61,109,107,105,272,263,265,42,94,110,106,117,268,262,13,112,47,98,104,121,273,259,260,261,32,118,103
     .word 116,269,40,41,44,258,99,102,114,274,55,56,57,0,120,100,101,270,52,53,54,0,122,115,119,275,49,50,51,337,338,340,344
_kb_key_data_92P_V200_2nd:
     .word 4141,4109,0,0,271,60,60,4372,4353,58,34,0,4139,266,4360,0,92,59,124,151,272,263,4361,4138,140
     .word 0,0,0,268,4358,4109,95,93,39,38,18,273,259,260,261,32,118,103,116,269,40,41,44,4354,0,159,64,274,4151,4152,4153,0,169,176,0,269,4148,4149,4150,0,0,223,33,275,149,4146,4147,4440,4436,4434,4433
_kb_key_data_92P_V200_diamond:
     .word 1,8205,8257,8273,8463,8240,8238,8365,8449,8328,8268,8271,2,8458,0,8456,8253,8269,8267,8265,8464,8455,8457,8234,8286,8270,8266,8277,8460,8454,8205,8272,8239,8258,8264,8281,8465,8451,8452,8453,8224,130,8276,8461,8232,8233,8236,0
     .word 8280,8260,8261,8462,8244,8245,8246,0,8282,8275,8279,8467,8241,8242,8243,8529,8530,8532,8536
_kb_key_data_92P_V200_lock:
     .word 1,8205,8257,8273,8463,8240,8238,8365,8449,8328,8268,8271,2,8458,0,8456,8253,8269,8267,8265,8464,8455,8457,8234,8286,8270,8266,8277,8460,8454,8205,8272,8239,8258,8264,8281,8465,8451,8452,8453,8224,130,8276,8461,8232,8233,8236,0
     .word 8280,8260,8261,8462,8244,8245,8246,0,8282,8275,8279,8467,8241,8242,8243,8529,8530,8532,8536
 
_kb_key_data_89_normal:
     .word 264,0,0,0,0,0,0,0,265,258,149,124,61,120,277
     .word 268,48,49,52,55,40,121,266,269,46,50,53,56,41,122,278,270,173,51,54,57,44,116,257,271,13,43,45,42,47,94,263,272,337,338,340,344
_kb_key_data_89_alpha:
     .word 264,0,0,0,0,0,0,0,265,112,107,102,97,120,277,268
     .word 118,113,108,103,98,121,266,269,119,114,109,104,99,122,278,270,32,115,110,105,100,116,257,271,13,117,111,106,101,94,263,272,337,338,340,344
_kb_key_data_89_2nd:
     .word 4360,0,0,0,0,0,0,0,4363,4354,159,176,39,4184,4373
     .word 273,60,34,58,4151,123,4185,18,274,62,92,4149,4152,125,4186,151,275,4372,4147,4150,59,91,4180,4353,271,4109,4139,4141,4138,93,140,263,272,4433,4434,4436,4440
_kb_key_data_89_diamond:
     .word 16648,0,0,0,0,0,0,0,16651,16642,16533,16508,16445
     .word 16472,277,16652,16432,16433,16436,16439,146,16650,16653,16430,16434,16437,16440,16425,16474,16662,16654,16557,16435,16438,16441,16428,16468,16641,16665,16397,16426,16431,16478,16647,16656,16721,16722,16724,16728

CALCULATOR:     
     .byte 0

|;;     
|;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;     
|KEY_CUP equ 1
|KEY_CDN equ 2
Webmaster du site.
Programmeur sur TI68K. Arkanoid, Nebulus, GFA-Basic.

Plus d'informations sur GFA-Basic (un langage Basic pour TI68K).
http://www.tigen.org/gfabasic
    
./Post n°1   Marquer comme non lu.
bidoo Ecrit le: Mardi 24 août 2004 à 16:00 Déconnecté(e)    Voir le profil de bidoo Envoyer un email à bidoo Envoyer un message privé à bidoo  
Membre: Newbie

Messages: 1
Membre n°410
Inscrit le 24 août 2004
regarde le code de ngetchx de Pedrom il est plus comprehensible je trouve
sinon va voir sur le forum asm de yaro
gné
    
./Post n°2   Marquer comme non lu.
GoldenCrystal Ecrit le: Mardi 24 août 2004 à 16:11 Déconnecté(e)    Voir le profil de GoldenCrystal Envoyer un email à GoldenCrystal Visiter le site WEB de GoldenCrystal Envoyer un message privé à GoldenCrystal  
Membre: Vétéran

Messages: 89
Membre n°18
Inscrit le 01 février 2004
Hmm, je n'étudierai pas en détail cette fonction, mais à première vue (et en me basant sur le tite de ce topic "ngetchx sans interruptions"), je dirais que ce code ne fonctionnera pas correctement.
A mon avis ce code est un hybride entre un GetKeyState et le ngetchx que tu veux. Essaye d'appuyer sur deux touches successivement, en gardant la première appuyée quand tu appuies sur la deuxième, et teste en changeant l'ordre... Il y a de fortes chances que lorsque la deuxième touche soit finalement appuyée, la valeur retournée par cette fonction soit toujours la même peu importe l'ordre dans lequel tu as appuyé sur les touches.
ngetchx sans interruptions, c'est impossible (ou imprécis, mais de toute façons ça ne ressemblerait pas à ça ^^), sans les interruptions d'AMS, certes, mais il faut que tu en utilises toi-même.
Si tu cherches un exemple de code de lecture de touche, cette routine est un mauvais exemple.
Si tu as besoin d'une routine, prends celle de PedroM (C sous GPL par contre), ou écris en une toi même, c'est encore ce qu'il y a de mieux. Tu pourras arranger la fonction selon tes besoins de cette manière. Par exemple, si tu n'as pas besoin d'utiliser les mêmes codes de touches que ngetchx (et il y a de fortes chances que ce soit le cas), tu pourras arranger ta fonction pour qu'elle retourne les mêmes valeurs sur tous les modèles, ce qui peut certainement s'avérer intéressant point de vue vitesse. Tu pourrais aussi gérer la répétition des touches pour toutes les touches, ou d'autres choses dans ce genre.
Bien sûr ça dépend de ce dont tu as besoin, mais je doute réellement que cette fonction soit adaptée à qui que ce soit ^^
Kupo !
    
./Post n°3   Marquer comme non lu.
geogeo Ecrit le: Mardi 24 août 2004 à 16:43 Déconnecté(e)    Voir le profil de geogeo Envoyer un email à geogeo Visiter le site WEB de geogeo Envoyer un message privé à geogeo  
Fondateur

Groupe: Staff de Ti-Gen
Groupe: Orage Studio

Messages: 4257
Membre n°3
Inscrit le 29 janvier 2004
Ouai je m'en doutais d'avoir ce genre de réponse. ^^
Il me faut une routine identique à getkey en Basic avec les même code de touche... mais avec les interruptions de désactivées.

Quoi qu'il en soit la routine que j'ai mis fonctionne correctement sur TI92+/V200 mais avec quelques bugs.
Je vais essayer de faire un truc.
Webmaster du site.
Programmeur sur TI68K. Arkanoid, Nebulus, GFA-Basic.

Plus d'informations sur GFA-Basic (un langage Basic pour TI68K).
http://www.tigen.org/gfabasic
    
./Post n°4   Marquer comme non lu.
GoldenCrystal Ecrit le: Mardi 24 août 2004 à 16:56 Déconnecté(e)    Voir le profil de GoldenCrystal Envoyer un email à GoldenCrystal Visiter le site WEB de GoldenCrystal Envoyer un message privé à GoldenCrystal  
Membre: Vétéran

Messages: 89
Membre n°18
Inscrit le 01 février 2004
Tu n'auras jamais de "routine identique à getkey en Basic" sans utiliser d'interruptions.
Et d'ailleurs, à moins que tu travailles avec le registre sr à 0x*7** ça n'a aucun sens de parler d'interruptions désactivées. Tu ne te rends peut-être pas compte, mais ce n'est pas parce que tu vas faire SetIntVec(AUTO_INT_2, DUMMY_HANDLER) que cette interruption sera désactivée (loin de là).
Kupo !
    
./Post n°5   Marquer comme non lu.
Sasume Ecrit le: Mardi 24 août 2004 à 17:06 Déconnecté(e)    Voir le profil de Sasume Envoyer un email à Sasume Visiter le site WEB de Sasume Envoyer un message privé à Sasume  
Membre: Titan

Messages: 918
Membre n°24
Inscrit le 01 février 2004
Si puisqu'elle est redirigée vers un rte.
Non ?
    
./Post n°6   Marquer comme non lu.
geogeo Ecrit le: Mardi 24 août 2004 à 17:14 Déconnecté(e)    Voir le profil de geogeo Envoyer un email à geogeo Visiter le site WEB de geogeo Envoyer un message privé à geogeo  
Fondateur

Groupe: Staff de Ti-Gen
Groupe: Orage Studio

Messages: 4257
Membre n°3
Inscrit le 29 janvier 2004
Non puisque c'est une interruption matérielle.

Quoiqu'il en soit je parle clairement des TIMERs, interruptions 1 et 5 principalement.
Webmaster du site.
Programmeur sur TI68K. Arkanoid, Nebulus, GFA-Basic.

Plus d'informations sur GFA-Basic (un langage Basic pour TI68K).
http://www.tigen.org/gfabasic
    
./Post n°7   Marquer comme non lu.
GoldenCrystal Ecrit le: Mardi 24 août 2004 à 17:14 Déconnecté(e)    Voir le profil de GoldenCrystal Envoyer un email à GoldenCrystal Visiter le site WEB de GoldenCrystal Envoyer un message privé à GoldenCrystal  
Membre: Vétéran

Messages: 89
Membre n°18
Inscrit le 01 février 2004
Bah, c'est pas désactiver une interruption (l'auto int est toujours reçue et éxécutée par le CPU), mais la détourner, c'est totalement différent. =)
Kupo !
    
./Post n°8   Marquer comme non lu.
geogeo Ecrit le: Mardi 24 août 2004 à 17:27 Déconnecté(e)    Voir le profil de geogeo Envoyer un email à geogeo Visiter le site WEB de geogeo Envoyer un message privé à geogeo  
Fondateur

Groupe: Staff de Ti-Gen
Groupe: Orage Studio

Messages: 4257
Membre n°3
Inscrit le 29 janvier 2004
Je sais, j'apprend rien.
Webmaster du site.
Programmeur sur TI68K. Arkanoid, Nebulus, GFA-Basic.

Plus d'informations sur GFA-Basic (un langage Basic pour TI68K).
http://www.tigen.org/gfabasic
    
./Post n°9   Marquer comme non lu.
Sasume Ecrit le: Mardi 24 août 2004 à 20:08 Déconnecté(e)    Voir le profil de Sasume Envoyer un email à Sasume Visiter le site WEB de Sasume Envoyer un message privé à Sasume  
Membre: Titan

Messages: 918
Membre n°24
Inscrit le 01 février 2004
Il me répondait je pense.

Cependant, je reste sceptique. Une interruption dont le handler ne contient qu'un rte peut être considérée comme désactivée non (puisqu'elle ne modifie rien) ?
    
./Post n°10   Marquer comme non lu.
geogeo Ecrit le: Mardi 24 août 2004 à 21:42 Déconnecté(e)    Voir le profil de geogeo Envoyer un email à geogeo Visiter le site WEB de geogeo Envoyer un message privé à geogeo  
Fondateur

Groupe: Staff de Ti-Gen
Groupe: Orage Studio

Messages: 4257
Membre n°3
Inscrit le 29 janvier 2004
Bah si elle modifie quand même le port 0x600018 je crois. Vref ça n'a pas d'importance puisque c'est pas le sujet.

Je viens de réaliser getkey en ASM qui correspond exactement au TI-Basic et capable d'être executé avec l'auto int n°1 et 5 redirigées. (Pour faire plaisir à GoldenCrystal ^^)

; Assembly Source File
; Created 24/08/2004, 13:36:53
; C prototype: unsigned short _kb_getkey (register unsigned char calc asm("%d4"));

     xdef    _kb_getkey

_kb_getkey:     
     move.l   d3,-(a7)
     moveq.l  #0,d0
     moveq.l  #0,d1
     
     lea.l    _kb_key_masks(PC),a0  ;Masque de column
     move.l   #8,d2      ;TI92+/V200
     tst.b    d4      ;Test calculatrice
     bne.s    _kb_getkey_loop_row
     move.l   #5,d2      ;TI89
     addq.l   #6,a0
_kb_getkey_loop_row:
     move.w   (a0),$600018
     lsr.l    #6,d1
     lsr.l    #6,d1
     move.b   $60001B,d1
     addq.l   #2,a0
     moveq.l  #7,d3       ;compteur de col 
_kb_getkey_loop_col:
     lsr.b    #1,d1
     bcc.s    _kb_getkey_lastrow   ;on quitte si detection d'une touche
     addq.l   #1,d0
     dbra.s   d3,_kb_getkey_loop_col   ;fin de boucle col
     dbra.s   d2,_kb_getkey_loop_row   ;fin de boucle row
_kb_getkey_lastrow:
     move.w   #$FFFE,$600018     ;masque du bit 0     
     lsr.w    #6,d1
     lsr.w    #6,d1
     move.b   $60001B,d1     ;on recupere la row
     move.b   d1,d2
     ;Détection calculatrice pour layout
     tst.b    d4
     bne.s    _kb_calc92_retval    ;TI92+
            
;Layout TI89     
_kb_calc89_retval:
     cmp.w    #48,d0
     bne.s    _kb_calc89_endarrows
;lecture des flèches
     lsr.b    #1,d1
     bcc.s    _kb_calc89_endarrows   ;on quitte si detection d'une touche
     addq.l   #1,d0       ;on incremente d0 (index)
     lsr.b    #1,d1
     bcc.s    _kb_calc89_endarrows   ;on quitte si detection d'une touche
     addq.l   #1,d0       ;on incremente d0 (index)
     lsr.b    #1,d1
     bcc.s    _kb_calc89_endarrows   ;on quitte si detection d'une touche
     addq.l   #1,d0       ;on incremente d0 (index)
     lsr.b    #1,d1
     bcc.s    _kb_calc89_endarrows   ;on quitte si detection d'une touche
;quitte avec 0 si aucune touche n'est pressée
     moveq.l  #0,d0
     move.l   (a7)+,d3
     rts
     
_kb_calc89_endarrows:  
     lsl.b    #1,d2
     bcc.s    _kb_calc89_alpha
     lsl.b    #1,d2
     bcc.s    _kb_calc89_diamond
     lsl.b    #1,d2
     bcc.s    _kb_calc89_shift
     lsl.b    #1,d2
     bcc.s    _kb_calc89_2nd
     lea.l    _kb_key_data_89_normal,a0
     bra.s    _kb_return
_kb_calc89_shift:
     lea.l    _kb_key_data_89_shift(PC),a0
     bra.s    _kb_return 
_kb_calc89_alpha:
     lea.l    _kb_key_data_89_alpha(PC),a0
     bra.s    _kb_return     
_kb_calc89_2nd:
     lea.l    _kb_key_data_89_2nd(PC),a0
     bra.s    _kb_return     
_kb_calc89_diamond:
     lea.l    _kb_key_data_89_diamond(PC),a0
     bra.s    _kb_return

;Layout TI92+/V200     
_kb_calc92_retval:
     cmp.w    #72,d0
     bne.s    _kb_calc92_endarrows
;lecture des flèches
     lsl.b    #1,d1
     bcc.s    _kb_calc92_endarrows     ;on quitte si detection d'une touche
     addq.l   #1,d0       ;on incremente d0 (index)
     lsl.b    #1,d1
     bcc.s    _kb_calc92_endarrows     ;on quitte si detection d'une touche
     addq.l   #1,d0       ;on incremente d0 (index)
     lsl.b    #1,d1
     bcc.s    _kb_calc92_endarrows     ;on quitte si detection d'une touche
     addq.l   #1,d0       ;on incremente d0 (index)
     lsl.b    #1,d1
     bcc.s    _kb_calc92_endarrows     ;on quitte si detection d'une touche
;quitte avec 0 si aucune touche n'est pressée
     moveq.l  #0,d0
     move.l   (a7)+,d3
     rts  

_kb_calc92_endarrows:
;lecture des stat keys
     lsr.b    #1,d2
     bcc.s    _kb_92P_V200_2nd
     lsr.b    #1,d2
     bcc.s    _kb_92P_V200_diamond
     lsr.b    #1,d2
     bcc.s    _kb_92P_V200_shift
     lsr.b    #1,d2
     bcc.s    _kb_92P_V200_lock     
     lea.l    _kb_key_data_92P_V200_normal(PC),a0
     bra.s    _kb_return
          
_kb_92P_V200_shift:
     lea.l    _kb_key_data_92P_V200_shift(PC),a0
     bra.s    _kb_return
_kb_92P_V200_2nd:
     lea.l    _kb_key_data_92P_V200_2nd(PC),a0
     bra.s    _kb_return     
_kb_92P_V200_diamond:
     lea.l    _kb_key_data_92P_V200_diamond(PC),a0
     bra.s    _kb_return    
_kb_92P_V200_lock:
     lea.l    _kb_key_data_92P_V200_lock(PC),a0   
 
_kb_return:
     add.w    d0,d0
     add.w    d0,a0
     move.w   (a0),d0
_kb_end:
     move.l   (a7)+,d3
     rts          
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; données
;masques précalculés
_kb_key_masks:
     dc.w $FDFF,$FEFF,$FF7F,$FFBF,$FFDF,$FFEF,$FFF7,$FFFB,$FFFD
     
;codes de touches
_kb_key_data_92P_V200_normal:
     dc.w   45,13,97,113,271,48,46,173
     dc.w   257,136,108,111,43,266,264,0
     dc.w   61,109,107,105,272,263,265,42
     dc.w   94,110,106,117,268,262,13,112
     dc.w   47,98,104,121,273,259,260,261
     dc.w   32,118,103,116,269,40,41,44
     dc.w   258,99,102,114,274,55,56,57
     dc.w   0,120,100,101,270,52,53,54
     dc.w   0,122,115,119,275,49,50,51
     dc.w   337,338,340,344

_kb_key_data_92P_V200_shift:
     dc.w   45,13,65,81,271,48,46,173
     dc.w   257,136,76,79,43,266,264,0
     dc.w   61,77,75,73,272,263,265,42
     dc.w   94,78,74,85,268,262,13,80
     dc.w   47,66,72,89,273,259,260,261
     dc.w   32,86,71,84,269,40,41,44
     dc.w   258,67,70,82,274,55,56,57
     dc.w   0,88,68,69,270,52,53,54
     dc.w   0,90,83,87,275,49,50,51
     dc.w   33112,33108,33106,33105
     
_kb_key_data_92P_V200_2nd:
     dc.w   4141,4109,0,63,271,60,62,4372
     dc.w   4353,58,34,0,4139,266,4360,0
     dc.w   92,59,124,151,272,263,4361,4138
     dc.w   140,0,190,0,268,4358,4109,95
     dc.w   93,39,38,18,273,4355,4356,4357
     dc.w   32,157,0,35,269,123,125,91
     dc.w   4354,0,159,64,274,4151,4152,4153
     dc.w   0,169,176,0,270,4148,4149,4150
     dc.w   0,0,223,33,275,149,4146,4147
     dc.w   4440,4436,4434,4433
     
_kb_key_data_92P_V200_diamond:
     dc.w   0,8205,8257,8273,8463,8240,8238,8365
     dc.w   8449,8328,8268,8271,0,8458,8456,0
     dc.w   8253,8269,8267,8265,8464,8455,8457,8234
     dc.w   8286,8270,8266,8277,8460,8454,8205,8272
     dc.w   8239,8258,8264,8281,8465,8451,8452,8453
     dc.w   8224,8278,8263,8276,8461,8232,8233,8236
     dc.w   8450,8259,8262,8274,8466,8247,8248,8249
     dc.w   0,8280,8260,8261,8462,8244,8245,8246
     dc.w   0,8282,8275,8279,8467,8241,8242,8243
     dc.w   8536,8532,8530,8529
     
_kb_key_data_92P_V200_lock:
     dc.w   0,0,0,0,0,0,0,0
     dc.w   0,0,0,0,0,0,0,0
     dc.w   0,0,0,0,0,0,0,0
     dc.w   0,0,0,0,0,0,0,0
     dc.w   0,0,0,0,0,0,0,0
     dc.w   0,0,0,0,0,0,0,0
     dc.w   0,0,0,0,0,0,0,0
     dc.w   0,0,0,0,0,0,0,0
     dc.w   0,0,0,0,0,0,0,0
     dc.w   33112,33108,33106,33105
 
 
_kb_key_data_89_normal:
     dc.w   264,0,0,0,0,0,0,0
     dc.w   265,258,149,124,61,120,277,268
     dc.w   48,49,52,55,40,121,266,269
     dc.w   46,50,53,56,41,122,278,270
     dc.w   173,51,54,57,44,116,257,271
     dc.w   13,43,45,42,47,94,263,272
     dc.w   338,337,344,340
 
_kb_key_data_89_shift:
     dc.w   264,0,0,0,0,0,0,0
     dc.w   265,80,75,70,65,88,277,268
     dc.w   86,81,76,71,66,89,266,269
     dc.w   87,82,77,72,67,90,278,270
     dc.w   32,83,78,73,68,84,257,271
     dc.w   13,85,79,74,69,94,263,272
     dc.w   16722,16721,16728,16724   
     
_kb_key_data_89_alpha:
     dc.w   264,0,0,0,0,0,0,0
     dc.w   265,112,107,102,97,120,277,268
     dc.w   118,113,108,103,98,121,266,269
     dc.w   119,114,109,104,99,122,278,270
     dc.w   32,115,110,105,100,116,257,271
     dc.w   13,117,111,106,101,94,263,272
     dc.w   33106,33105,33112,33108
     
_kb_key_data_89_2nd:
     dc.w   4360,0,0,0,0,0,0,0
     dc.w   4361,4354,159,176,39,4184,4373,273
     dc.w   60,34,58,4151,123,4185,18,274
     dc.w   62,92,4149,4152,125,4186,151,275
     dc.w   4372,4147,4150,59,91,4180,4353,271
     dc.w   4109,4139,4141,4138,93,140,263,272
     dc.w   4434,4433,4440,4436
     
_kb_key_data_89_diamond:
     dc.w   8456,0,0,0,0,0,0,0
     dc.w   8457,64,8341,8316,157,8280,277,8460
     dc.w   156,8241,8244,8247,0,8281,95,8461
     dc.w   158,8242,8245,8248,169,8282,190,8462
     dc.w   8365,8243,8246,8249,8236,8276,8449,8463
     dc.w   8205,0,0,38,33,136,8455,8464
     dc.w   8530,8529,8536,8532 
     
Webmaster du site.
Programmeur sur TI68K. Arkanoid, Nebulus, GFA-Basic.

Plus d'informations sur GFA-Basic (un langage Basic pour TI68K).
http://www.tigen.org/gfabasic
    
./Post n°11   Marquer comme non lu.
GoldenCrystal Ecrit le: Mardi 24 août 2004 à 21:47 Déconnecté(e)    Voir le profil de GoldenCrystal Envoyer un email à GoldenCrystal Visiter le site WEB de GoldenCrystal Envoyer un message privé à GoldenCrystal  
Membre: Vétéran

Messages: 89
Membre n°18
Inscrit le 01 février 2004
[EDIT: je répondais à Sasume]
Oui, tu peux onsidérer qu'elle est désactivée, mais elle ne l'est pas, c'est seulement le code de l'interruption qui a été désactivé. Le cpu va toujours répondre à l'interruption, et donc consommer quelques cycles (bien sûr c'est assez insignifiant). Pour certaines opérations qui ne doivent pas être interrompues, ou des opérations qui demandent un timing très précis, tu ne peux pas considérer le rte comme une interruption désactivée.
-Edité le Mardi 24 août 2004 à 21:49 par GoldenCrystal-
Kupo !
    
./Post n°12   Marquer comme non lu.
geogeo Ecrit le: Mardi 24 août 2004 à 21:53 Déconnecté(e)    Voir le profil de geogeo Envoyer un email à geogeo Visiter le site WEB de geogeo Envoyer un message privé à geogeo  
Fondateur

Groupe: Staff de Ti-Gen
Groupe: Orage Studio

Messages: 4257
Membre n°3
Inscrit le 29 janvier 2004
Si vous trouvez des optimisations à faire n'hésitez pas. :)
Pour répondre au post de GoldenCrystal que j'ai zappé :D

Hmm, je n'étudierai pas en détail cette fonction, mais à première vue (et en me basant sur le tite de ce topic "ngetchx sans interruptions"), je dirais que ce code ne fonctionnera pas correctement.
A mon avis ce code est un hybride entre un GetKeyState et le ngetchx que tu veux. Essaye d'appuyer sur deux touches successivement, en gardant la première appuyée quand tu appuies sur la deuxième, et teste en changeant l'ordre... Il y a de fortes chances que lorsque la deuxième touche soit finalement appuyée, la valeur retournée par cette fonction soit toujours la même peu importe l'ordre dans lequel tu as appuyé sur les touches.
ngetchx sans interruptions


L'ordre fonctionne correctement tout comme ngetchx. =)

, c'est impossible (ou imprécis, mais de toute façons ça ne ressemblerait pas à ça ^^), sans les interruptions d'AMS, certes, mais il faut que tu en utilises toi-même.
Si tu cherches un exemple de code de lecture de touche, cette routine est un mauvais exemple.


Je pense que non puisque elle me permet de faire l'impossible :D

Si tu as besoin d'une routine, prends celle de PedroM (C sous GPL par contre), ou écris en une toi même, c'est encore ce qu'il y a de mieux. Tu pourras arranger la fonction selon tes besoins de cette manière.


Celle de Pedrom est incomplète.

Par exemple, si tu n'as pas besoin d'utiliser les mêmes codes de touches que ngetchx (et il y a de fortes chances que ce soit le cas), tu pourras arranger ta fonction pour qu'elle retourne les mêmes valeurs sur tous les modèles, ce qui peut certainement s'avérer intéressant point de vue vitesse. Tu pourrais aussi gérer la répétition des touches pour toutes les touches, ou d'autres choses dans ce genre.


J'ai besoin d'une fonction identique à getkey du TI-Basic dont oui j'utilise toute les conbinaisons possibles.


Au fait si Kevin passse par là, il y a un bug avec a68k et gnu68k.

dc.w   0,1,2,3

et différent de
dc.w   0,  1,  2,  3


Bref dans l'exemple n°2, 1,2,3 sont ignorés.
-Edité le Mardi 24 août 2004 à 21:57 par geogeo-
Webmaster du site.
Programmeur sur TI68K. Arkanoid, Nebulus, GFA-Basic.

Plus d'informations sur GFA-Basic (un langage Basic pour TI68K).
http://www.tigen.org/gfabasic
    
./Post n°13   Marquer comme non lu.
GoldenCrystal Ecrit le: Mardi 24 août 2004 à 22:03 Déconnecté(e)    Voir le profil de GoldenCrystal Envoyer un email à GoldenCrystal Visiter le site WEB de GoldenCrystal Envoyer un message privé à GoldenCrystal  
Membre: Vétéran

Messages: 89
Membre n°18
Inscrit le 01 février 2004
geogeo, si tu veux écrire une routine compatible avec ngetchx, garde à l'esprit que:
Si tu presses une touche, elle sera retournée, mais que si tu presses ensuite une autre touche en gardant la première enfoncée ça doit toujours te retourner la seconde, quelle qu'elle soit.
(Je passe sur les autre détails spécifiques à l'implémentation de getkey() en TIBasic, vu qu'a mon avis ils ne te sont pas nécéssaires... En fait je ne vois même pas pourquoi tu cherches à être compatible avec getkey, mais bon...)
Sinon, juste comme ça, les "masques précalculés" (:D), ça peut s'optimiser avec des ASR.w Dn, des ROL.W Dn ou ROR.W Dn ou encore avec des ADD.w Dn,Dn;ADDQ.w #1,Dn (je ne sais pas ce qui est le plus rapide)
-Edité le Mardi 24 août 2004 à 22:06 par GoldenCrystal-
Kupo !
    
./Post n°14   Marquer comme non lu.
GoldenCrystal Ecrit le: Mardi 24 août 2004 à 22:14 Déconnecté(e)    Voir le profil de GoldenCrystal Envoyer un email à GoldenCrystal Visiter le site WEB de GoldenCrystal Envoyer un message privé à GoldenCrystal  
Membre: Vétéran

Messages: 89
Membre n°18
Inscrit le 01 février 2004
geogeo :
L'ordre fonctionne correctement tout comme ngetchx. =)

La routine sauvegarde le dernier résultat ? Si ce n'est pas le cas je ne crois pas qu'elle retourne vraiment les touches comme il faut
Je pense que non puisque elle me permet de faire l'impossible :D
#trinon# ngetchx ne fonctionne pas comme ça. Le principe des interruptions est que la lecture des touches fonctionne n'importe quand, alors que dans le meilleurs des cas (je ne crois pas que ce le soit ici), une routine sans interruptions mettrait à jour le buffer clavier que lors de son appel -> très forte probabilité de manquer des touches.
Celle de Pedrom est incomplète.
Ah... A quel niveau ? C'est certainement possible de corriger ça.
-Edité le Mardi 24 août 2004 à 22:15 par GoldenCrystal-
Kupo !
    
./Post n°15   Marquer comme non lu.
Kevin Kofler Ecrit le: Mardi 24 août 2004 à 22:43 Déconnecté(e)    Voir le profil de Kevin Kofler Envoyer un email à Kevin Kofler Visiter le site WEB de Kevin Kofler Envoyer un message privé à Kevin Kofler  
Administrateur

Groupe: Staff de Ti-Gen

Messages: 4814
Membre n°40
Inscrit le 08 février 2004
geogeo :
Au fait si Kevin passse par là, il y a un bug avec a68k et gnu68k.

dc.w   0,1,2,3

et différent de
dc.w   0,  1,  2,  3


Bref dans l'exemple n°2, 1,2,3 sont ignorés.

Not a bug. Les espaces ne sont pas permis après les virgules par A68k. Tout ce qui suit est interprété comme un commentaire.

En revanche, GNU as ne fonctionne pas comme ça, je ne pense pas que tu aies essayé avec GNU as. Revérifie s'il te plaît.
Membre de l'équipe de TIGCC: http://tigcc.ticalc.org
Mainteneur du portage Linux/Unix de TIGCC: http://tigcc.ticalc.org/linux/
Membre de l'équipe de CalcForge: http://www.calcforge.org:70/

Participez à la reprise de Ti-Gen!
    
./Post n°16   Marquer comme non lu.
geogeo Ecrit le: Mercredi 25 août 2004 à 00:02 Déconnecté(e)    Voir le profil de geogeo Envoyer un email à geogeo Visiter le site WEB de geogeo Envoyer un message privé à geogeo  
Fondateur

Groupe: Staff de Ti-Gen
Groupe: Orage Studio

Messages: 4257
Membre n°3
Inscrit le 29 janvier 2004
En revanche, GNU as ne fonctionne pas comme ça, je ne pense pas que tu aies essayé avec GNU as. Revérifie s'il te plaît.


Oui en effet ça fonctionne très bien, désolé. :)
Webmaster du site.
Programmeur sur TI68K. Arkanoid, Nebulus, GFA-Basic.

Plus d'informations sur GFA-Basic (un langage Basic pour TI68K).
http://www.tigen.org/gfabasic
    
  :: Index » Forum Ti68K » Programmation Assembleur 68K » ngetchx sans interruptions (16 réponse(s))
Pages : 1/1    |« « [1] » »|

.Répondre à ce sujet
Les boutons de code
[B]old[I]talic[U]nderline[S]trikethrough[L]ine Flip Hori[Z]ontallyFlip [V]erticallySha[D]ow[G]low[S]poilerCode [G][C]ite
Bullet [L]istList Item [K] Link [H][E]mail[P]icture SmileysHelp
Couleurs :
Saisissez votre message
Activer les smileys
     

Forum de Ti-Gen v3.0 Copyright ©2004 by Geoffrey ANNEHEIM
Webmaster: Kevin KOFLER, Content Admins: list, Server Admins: Tyler CASSIDY and Kevin KOFLER, DNS Admin: squalyl
Page générée en 56.96ms avec 18 requetes