Caractères Hexa en assembleur

[Obsidian]

Envoyé par darkofmadness

J'ai trouvé !!!
enfin en tout cas ca marche ^^

Félicitations ! Et merci d'avoir joint le code à chaque fois.
Sache toutefois que c'est de la bidouille qui s'ajoute et de la bidouille et que cela risquera de te mener tôt ou tard dans une impasse.

J'ai une dernière question (après j'arrête promis! tu m'as assez aidé !)
Si je fais Fn+F3, ca me fait ":" cependant, si je reste appuyé sur ces deux touches et que je lache Fn avant F3 et qu'ensuite je lache F3, il garde en memoire l'appui, et ne s'arrête pas de me mettre ":"
La dessus je vois pas trop comment je dois faire
Merci

C'était à prévoir, malheureusement. Pour cela, il faut déjà que tu détermines si c'est ton clavier qui gère cette répétition ou si c'est le système d'exploitation du PC qui l'émule tant qu'il n'a pas reçu le code de libération.

Ensuite, dans les deux cas, il faudra provoquer la libération de la touche. Pour cela, il faut que tu voies déjà si ton logiciel détecte les relachements de touche à son niveau, et de quelle manière. En principe, tu dois avoir une table dans laquelle tu mets les points d'entrée de toutes les routines que tu as écrites et que tu m'as présentées ici. Cette table est exploitée par une procédure qui les appelle et qui, en principe, doit ou non conserver l'état de chaque touche (en mettant un flag à 1 ou à 0).

Selon les cas, il faudra soit apprendre à utiliser la routine déjà en place pour intégrer ton code à l'existant (et surtout éviter d'interférer avec), soit mettre en place ta propre procédure si ce cas n'avait pas été prévu jusqu'ici.

[darkofmadness]

Salut à toi !
Merci pour tes recherches (ou ton génie ! )

Ensuite je pense pas être prêt ou assez expérimenté en Assembleur pour me lancer dans quelquechose d'énorme comme ca (tout reprendre....)

En tout cas je vais voir, avec ta première solution si je peux m'en sortir !

Et oui c'est le firmware (donc le clavier) qui gère la répétition (possibilité aussi de la désactivé, mais je dois la garder)
ensuite pour les états de relachement je ne sais pas trop, enfin je sais qu'ils sont géré pour les touches de fonctions, mais je ne crois pas qu'ils le soient pour les touches "classiques".
Enfin je vais regarder et je reviens surement vers toi ^^

En tout cas, je tiens vraiment à te remercier pour toutes tes explications et ton aide.

Je mets résolu?

[Obsidian]

Hello

Envoyé par darkofmadness

Salut à toi !
Merci pour tes recherches (ou ton génie ! )

Ça, c'est vraiment TRÈS exagéré !

En tout cas je vais voir, avec ta première solution si je peux m'en sortir !

Et oui c'est le firmware (donc le clavier) qui gère la répétition (possibilité aussi de la désactivé, mais je dois la garder) ensuite pour les états de relachement je ne sais pas trop, enfin je sais qu'ils sont géré pour les touches de fonctions, mais je ne crois pas qu'ils le soient pour les touches "classiques".
Enfin je vais regarder et je reviens surement vers toi ^^

C'est effectivement ce qu'il y a de mieux à faire.

En tout cas, je tiens vraiment à te remercier pour toutes tes explications et ton aide.

Je mets résolu?

Oui, pour le moment. Tu pourras ultérieurement rebasculer ta discussion à l'état non résolu si nécessaire.

Bon courage.

[darkofmadness]

Salut Obsidian !!
j'avais plus internet depuis la dernière fois !
je profite de l'avoir pour te demander un coup de main (encore )
tu te rappelles mon dernier problème?
avec les lignes que j'ai fais, lorsque je fait "Fn"+"F3" (pour sortir ":" par exemple)
ben, si je lache "Fn" avant "F3" les ":" sortent en répétition meme je la lache F3 !
et ca je vois pas comment le gerer?
Merci de ton aide
ex:
Fn+F3 -> :::::::::::
je lache Fn en restant appuyer sur F3 -> ::::::::
et je lache F3 -> ::::::::::::::
jusqu'a ce que je rappuies sur F3. (ensuite si je refait Fn+F3 ca ne marche plus !)

Aide moi stp, je suis perdu et c'est urgent
Merci !

[Obsidian]

C"est du déboguage et il faudrait que l'on audite le code en entier pour pouvoir te dire avec certitude d'où ça vient. La dernière fois, on a dit qu'il fallait déjà vérifier si c'était bien ton clavier qui envoyait des scan codes à répétition où si c'était le système d'exploitation qui les simulait tant qu'il n'avait pas reçu le code de relachement de la touche. Tu m'avais alors indiqué que c'était bien ton clavier qui les émettait et que, donc, le problème venait de ton code.

À mon avis, ta routine doit estimer qu'une seule touche doit pouvoir être enfoncée à un moment donné, hors touches spéciales, lesquelles touches spéciales sont représentées par leur propre bit, défini dans les equates que tu nous as présentées :

Code :

1
2
3
4
5
6
7
8
LEFT_CTRL_BIT:		equ		01
LEFT_SHIFT_BIT:		equ		02
LEFT_ALT_BIT:		equ		04
LEFT_GUI_BIT:		equ		08
RIGHT_CTRL_BIT:		equ		10h
RIGHT_SHIFT_BIT:	equ		020h
RIGHT_ALT_BIT:		equ		040h
RIGHT_GUI_BIT:		equ		080h

Dans cette table, la touche FN n'apparaît pas. J'imagine alors qu'après les avoir passées en revue, la routine doit considérer que ce qui reste est forcément une touche ordinaire.

Par ailleurs, « ksc_putkey » ne doit pas être faite pour être appelée deux fois consécutivement sans faire un tour de boucle d'abord. Elle doit probablement être faite pour ne garder trace que de la première ou dernière touche enfoncée. Comme, en plus, tu envoies des scan codes qui ne correspondent pas réellement à ceux émis par tes touches, la routine ne doit plus avoir aucun moyen de détecter automatiquement la libération de la touche.

[darkofmadness]

merci !
comment dois je faire alors pour envoyer altgr, puis 0 par exemple? sans utiliser deux fois ksc_putkey?

dois je creer un bit pour ma touche fn? (si oui lequel et comment?)

j'ai l'impression de devoir tout recommencer (mais le j'ai pas le temps!)

[Obsidian]

Comme je te le dis, il te faut les spécifications de « ksc_putkey » pour savoir réellement comment elle marche et comment on doit l'utiliser. Essaie de poster le code ici s'il n'est pas trop long et s'il n'est pas trop « privé ». Je ne pense pas que le firmware d'un clavier soit d'une importance stratégique.

Autrement, on ne peut pas faire autre chose que des suppositions. Ton code n'est pas public et on ne peut pas chercher sur Google comment il fonctionne.

[darkofmadness]

salut et merci.
desolé de rep que maintenant, je t'envois par mp.

Merci !

[darkofmadness]

salut !

Bon je pense avoir trouvé, j'ai du changer de boucle, sinon je n'en sortais plus !
et je l'ai amélioré un peu (je crois)

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
;========================================================================
; FUNCTION: ksc_putkey
;
; calls either ps2key_putkey or usbkey_putkey, depending upon the
; keyboard currently being supported.
;
;
;========================================================================
 
 
ksc_putkey:
    push    A
    mov     A,[dual_ifc_keyboard]
    cmp     A,PS2_KEYBOARD
    pop     A
    jnz     .usb
    call ps2key_putkey
    ret
 
.usb:
 
	push	A
	CMP	A,T_FONCTION				;T_FONCTION
	jz	.Traite_T_FONCTION
	pop	A
 
	mov	A, [ksc_down_up]
	cmp	a,0
	jnz	.tdown 
	jmp	.suite_emission
 
.tdown:
	mov	A,[usb_key_count]
	cmp	a,0
	jnz	.inhibe
 
.suite_emission:
	POP	A
 
 
 
	push	A
	CMP	A,AT101KB_F3
	jz	.TF33
	pop	A
 
 
 
	push	A
	mov	A, [ksc_down_up]
	cmp	a,0
	jnz	.tdown_suite 
	pop	A
	push	A
	cmp	A,[ksc_last_transmit_caracter]
	jnz	.inhibe
.tdown_suite: 
	pop	A
	mov	[ksc_last_transmit_caracter],A
	call   usbkey_putkey
	ret
 
.inhibe:
	POP	A
	ret
 
.Traite_TMODE:
	pop	A
	call   usbkey_putkey
	ret
 
.Traite_T_FONCTION:
	pop	A
	mov	A, [ksc_down_up]
	cmp	a,0
	jnz	.set_flag_T_FONCTION  
 
	MOV	A,00h
	mov	[ksc_flags],A
;	jmp	done_FoundKey
	ret
 
.set_flag_T_FONCTION:
	MOV	A,01h
	mov	[ksc_flags],A
;	jmp	done_FoundKey
	ret
 
.tx_up_key_Fonction:
	mov	A,[ksc_last_transmit_caracter]
;	jmp	done_FoundKey
 
.tx_down_key_Fonction:
	mov	[ksc_last_transmit_caracter],A
	call   usbkey_putkey
;	jmp	done_FoundKey
	ret
 
 
;.TEST_CAPSLOCK:
;	Push	A
;	MOV	A,[ksc_p3out]
;	AND 	A,00000010b
;	CMP	A,CAPS_LOCK_LED
;	ret
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 
.TF33:
	mov	A, [ksc_down_up]
	cmp	a,0
	jnz	.TF3 
	pop	A
	jmp	.tx_up_key_Fonction
.TF3:
 
	mov	A,[ksc_flags]
	cmp	a,0
	POP	A
	jnz	.DEUXPTS
	jmp	.tx_down_key_Fonction
 
 
 
.DEUXPTS:
;	jmp .TEST_CAPSLOCK
	Push	A
	MOV	A,[ksc_p3out]
	AND 	A,00000010b
	CMP	A,CAPS_LOCK_LED
	JZ .DPTS
	POP	A
	MOV	A,AT101KB_LEFTSHIFT
	call   usbkey_putkey
	MOV	A,AT101KB_RIGHTANGLE
	jmp  .tx_down_key_Fonction
 
 
.DPTS:
	POP	A
	MOV	A,AT101KB_RIGHTANGLE
	jmp  .tx_down_key_Fonction

je n'ai donc plus de soucis pour les touches en "accès direct" (sans avoir a créer une combinaison de touches)
mais j'ai du mal pour les combinaisons.
Dans l'exemple, il envoies bien shift appuyé+deux points, mais il ne relache pas shift !
Tu aurais une idée? comment je pourrais faire?
En manipulant les bits? j'ai essayé sans grand succès

J'ai l'impression d'être tout proche peux-tu m'aider?

Merci par avance !

[Obsidian]

Regarde la fonction que tu m'as envoyée :

usbkey_putkey:
call usb_power_key
jc .done_putkey

call usb_consumer_key
jc .done_putkey

call ksc_modifier ;check for a modifier
jnc .non_modifiers
mov A, USB_REPORT_KEY ; show that a report is required
mov [usb_tx_required], A
mov A,[ksc_mod0]
mov [usb_last_mod],A
jmp .done_putkey

.non_modifiers:
…

Ta routine vérifie si le code reçu correspond à une power key (on/off, sleep/wake), puis à une consumer key (volume +/-), puis à un modifier (donc Shift, Ctrl ou Alt) et, enfin, considère par défaut que c'est une touche ordinaire.

Il se trouve que, malheureusement, « ksc_modifier » est commune aux clavier PS/2 et USB et ne se trouve donc pas dans le code que j'ai reçu. En plus, si je me fie aux equates plus haut, la touche Fn ne doit pas encore en faire partie.

Quoi qu'il en soit, cette routine doit probablement conserver trace des modificateurs enfoncés. Comme tu émets artificiellement LEFT_SHIFT, la routine en tient compte mais ne détecte jamais sa libération puisque la touche, en réalité, n'a jamais été enfoncée.

Tu peux essayer de t'en sortir en générant immédiatement les événements de libération de F3 puis de Fn en réglant le bit ksc_down_up mais ça reste de la bidouille : on ne peut toujours pas garantir ce qui va se passer si la touche est « enfoncée » et « relachée » avant que ton programme ait eu le temps de faire un tour de boucle.

Surtout qu'après examen du reste de ta routine, il y a du vrai partiel dans ce que l'on a supposé jusqu'ici. En particulier, elle compte le nombre de touches enfoncées à un moment donné entre 0 et 255 maximum (largement suffisant puisque supérieur aux nombres de touches physiques) mais entretient un buffer d'une dizaine d'entrées pour conserver la trace des scan codes effectivement enfoncés.

Même si tu es tenu par une deadline, je suis obligé de te dire que, pour le moment, tu fuis en avant. C'est compréhensible mais tu vas avoir de plus en plus de bugs bizarres provoqués par les palliatifs que tu auras mis en place. Si tu en as la possibilité, je te conseille de livrer un programme fonctionnel à la date convenue et de réserver du temps derrière pour le mettre définitivement au propre.

[darkofmadness]

Je te remercie pour ton temps de recherche ! Penses-tu qu'avec le dernier code que j'ai poster je peux men sortir? Le probleme c'est que je ne vois pas comment simuler la touche relâcher ! Étant donné que je dois sortir de la fonction pour aller interroger usbkey_putkey et quensuite je dois retourner dans la principale (ce que je fais avec jmp .tx_down_key )
Je peux me faire en modifiant le bit de left shift ? Mais comment je n'y arrive pas. Ou en passant ksc_down_up à o?

Voici donc ksc_modifier :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
;========================================================================
; Decrement the time constant in the counter ARRAY
;========================================================================
ksc_Debounce_Task:
	push X							    ; save X and A
	push A
	mov X, DEBOUNCE_ARRAY_SIZE          ;load array size
 
.debounce_check:
      mov A, [X + ksc_db_keys - 1]      ;check if is a free location
	cmp A, 0FFh                         ;if yes process another location
	jz  .next_value_process
	mov A, [X + ksc_db_counts - 1]      ;decrement the right counter in
	dec A                               ;the array
	mov [X + ksc_db_counts - 1], A      ;if the value is different from 0
	jnz .next_value_process             ;process another location in the array
	mov A, 0FFh                         ;if 0 (time expired) load 0FFh 
	mov [X + ksc_db_keys - 1] ,A        ;(free position)
 
.next_value_process:
	dec X								; decrement position
	jnz .debounce_check			        ;check this new position (if not 0)
	pop A								; restore A and X
	pop X
	ret
 
    XPAGEOFF
mod_key_table:
    db      AT101KB_LEFTCTRL,AT101KB_LEFTSHIFT
    db      AT101KB_LEFTALT,AT101KB_LEFTGUI
    db      AT101KB_RIGHTCTRL,AT101KB_RIGHTSHIFT
    db      AT101KB_RIGHTALT,AT101KB_RIGHTGUI
    db      AT101KB_APPLICATION
mod_bit_table:
    db      LEFT_CTRL_BIT,LEFT_SHIFT_BIT
    db      LEFT_ALT_BIT,LEFT_GUI_BIT
    db      RIGHT_CTRL_BIT,RIGHT_SHIFT_BIT
    db      RIGHT_ALT_BIT,RIGHT_GUI_BIT
    db      APP_BIT
 
    XPAGEON
 
;currently we are not counting the application key as a modifier key.
;so there are only 8 modifiers.
NUM_MODIFIERS: equ 8
 
 
ksc_modifier:
 
	push	X
	push	A	
	mov	X,ksc_mod0                            ;point X at mod0
 
 
    ;removed, not currently considering the application key as a modifier
    ;cmp     A,AT101KB_APPLICATION                   ;if app key
    ;jnz     .lp0
    ;mov     X,ksc_mod1                            ;point at mod1
 
 
.lp0:
	mov     [ksc_work],A                            ;store key in work byte
	mov     A,(NUM_MODIFIERS - 1)                   ;initialize A to number of modifiers
.lp1:
	push    A                                       ;save index
	index   mod_key_table                           ;get lookup
	cmp     A,[ksc_work]                            ;compare to key
	pop     A                                       ;restore index
	jz      .lp2                                    ;compare was a success, key found
	dec      A          
	jc      .non_modifier                           ;index < 0, non-modifier
	jmp     .lp1
 
.lp2:
	index   mod_bit_table                           	;now index into bit to set/clear
	push	A						; clear or set modifier bit
	mov		A, [ksc_down_up]               		; depending on if key went
	cmp		A, 00h                                  ; up or down
	pop		A                                       ; restore bit pattern
	jz		.mod0_up                                ; modifier key went down
	or		[X + 0], A                              ; set bit
	jmp		.done_putkey
 
.mod0_up:						; else, modifier key went up
	cpl                                             ; so clear bit
	and		[X + 0], A     
 
.done_putkey:                                       ;set carry indicating modifier found
    SETC    
 
.exit:
	pop     A                                       ;restore A,X
	pop	X
	ret
 
.non_modifier:                                      ;clear carry indicating no modifier found
	CLEARC                  
	jmp     .exit

Je comprend de plus en plus que c'est de la bidouille mais je dois len sortir avec ça pour l'instant.
Merci de ton aide

[Obsidian]

Ça se fait effectivement en repassant ksc_down_up à zéro, mais n'oublie pas de remettre ce bit dans l'état où tu l'as trouvé avant la fin de la séquence, sinon ça risque de perturber le reste de la boucle.

À part cela, la routine que tu me présentes confirme bien ce que l'on pensait : il y a un octet en mémoire, nommé « ksc_mod0 » qui code chaque modifier sur un bit (et qui permet par conséquent de savoir en un coup d'œil si au moins l'un d'entre eux est enfoncé), et un symbole NUM_MODIFIERS qui permet de savoir combien on en a défini en l'état actuel des choses.

On voit également que toi ou ton prédécesseur s'est rendu compte qu'il n'y a que huit bits dans un octet et que c'était donc difficile d'en ajouter de nouveaux. Il y a une tentative pour mettre en place « ksc_mod1 » à côté, mais ça demande de modifier la routine entière pour qu'elle le reconnaisse. Pas très difficile mais un peu long. Du coup, « toi ou ton prédécesseur » a décidé que, finalement, la touche « Application » ne serait pas considérée comme un modifier.

C'est bon comme cela tant que l'on en reste à cette version du logiciel mais si c'est bien ton prédécesseur qui a fait cela, alors tu comprends qu'il faut faire de l'archéologie, non seulement en ré-auditant tout ce qui a été écrit jusqu'ici mais en essayant de comprendre les choix du programmeur. Tu risques donc de te mettre toi-même dans cette situation si tu laisses traîner des palliatifs trop longtemps.

[darkofmadness]

mmh... je comprend et je te remercie,
j'ai cependant tout essayé (passer a 0, passer a 1) rien n'y fait.

Je n'arrive pas a forcer les bits. Par exemple si je passe LEFTSHIFT_BIT a 1, il devrait en resortir un SHIFT appuyé non?
et il me suffirait de le repasser a 0 non?

Parce que je n'ai pas reussi a modifier ksc_down_up pour controler l'état de shift.

JE te remercie encore une fois pour ton temps.

[Obsidian]

Envoyé par darkofmadness

mmh... je comprend et je te remercie,
j'ai cependant tout essayé (passer a 0, passer a 1) rien n'y fait.

Je n'arrive pas a forcer les bits. Par exemple si je passe LEFTSHIFT_BIT a 1, il devrait en resortir un SHIFT appuyé non?
et il me suffirait de le repasser a 0 non?

LEFT_SHIFT_BIT est le masque qui correspond au bit qui représente la touche Shift de gauche dans le registre des modificateurs enfoncés « ksc_mod0 ». C'est ce dernier qu'il faut modifier. Plus précisément :

1. Ta routine regarde si le scan code de la touche enfoncée se trouve dans la table des modificateurs « mod_key_table » ;
2. Si c'est le cas, elle récupère le bit correspondant dans la table d'à côté « mod_bit_table » en y piochant la valeur située au même rang ;
3. En fonction de la valeur de « ksc_down_up », la routine va faire un OR de cette valeur ou un AND du complément de cette valeur sur le registre « ksc_mod0 » pour mettre le bit adéquat respectivement à 1 ou à 0 sans toucher aux autres.

C'est plus clair avec un tableau :

              7   6   5   4   3   2   1   0
            +---+---+---+---+---+---+---+---+
 ksc_mod0 : |   |   |   |   |   |   |   |   |
            +---+---+---+---+---+---+---+---+
              |   |   |   |   |   |   |   \____ LEFT  CTRL
              |   |   |   |   |   |   \________ LEFT  SHIFT
              |   |   |   |   |   \____________ LEFT  ALT
              |   |   |   |   \________________ LEFT  GUI
              |   |   |   \____________________ RIGHT CTRL
              |   |   \________________________ RIGHT SHIFT
              |   \____________________________ RIGHT ALT
              \________________________________ RIGHT GUI

Parce que je n'ai pas reussi a modifier ksc_down_up pour controler l'état de shift.
JE te remercie encore une fois pour ton temps.

Il suffit d'écrire 1 ou 0 dedans et d'appeler ta routine ensuite. Par contre, il faut restaurer son état une fois que c'est fait. Tu pourrais le mettre dans la pile mais tu as besoin de la valeur de A. Le plus simple consiste donc à l'enregistrer dans une case mémoire réservée à cet effet avec

Code :

    mov     [ksc_ta_case_memoire],A

et à la restaurer ensuite par l'instruction symétrique de celle-ci.


On pourrait penser que ce serait plus simple d'aller modifier directement le bit Shift en question dans ksc_mod0 mais ce n'est pas le cas : il faudrait de toutes façons restaurer son état et l'appui sur un modificateur se traduit par un événement qu'il faut de toutes façons envoyer à l'hôte… selon les cas ! Parce qu'on dirait que l'USB n'est pas géré exactement de la même façon que le reste par ton clavier.

[darkofmadness]

je te remercie c'est plus clair, mais j'ai un peu du mal a comprendre, pourquoi on pourrait pas modifier le bit.

mais donc si je veux mettre ksc_down_up a 0
je dois juste faire un truc du genre

Code :

1
2
3
4
5
 
POP	A
MOV	A,00h
mov	[ksc_down_up],A
call	usbkey_putkey

dpnc je ne peux pas simuler la touche shift sans passer par son scancode ?

merci encore !

[Obsidian]

Envoyé par darkofmadness

je te remercie c'est plus clair, mais j'ai un peu du mal a comprendre, pourquoi on pourrait pas modifier le bit.

Encore une fois, sans avoir audité le code entier et en détails, on ne peut faire que des suppositions. Ensuite, il est important de retenir que ton clavier ne va pas envoyer le caractère correspondant à ta combinaison de touches mais les scan codes de celle-ci. Ça veut dire que, dans tous les cas, tu es obligé de provoquer d'une manière ou d'une autre l'envoi des deux événements pour que le PC hôte les traite comme ça lui chante.

Tu peux modifier le bit mais il faudra le sauvegarder et le restaurer avant de sortir, ce qui peut s'avérer plus compliqué que simuler un appui en envoyant son scan code. De plus, d'autres procédures sont mises en œuvre lorsque tu appelles la routine normalement, comme le fait de mettre un flag dans un état particulier pour demander l'envoi d'un rapport USB. En plus, la même routine copie la valeur de ksc_mod0 une fois modifiée dans usb_last_mod, probablement pour faire la différence des deux dans une boucle quelconque plus tard et voir s'il est nécessaire de provoquer ou non un envoi de données.

Fais des tests et tu verras.

[quote]mais donc si je veux mettre ksc_down_up a 0
je dois juste faire un truc du genre

Code :

1
2
3
4
5
 
POP	A
MOV	A,00h
mov	[ksc_down_up],A
call	usbkey_putkey

Non, pas tout-à-fait. Il faut d'abord sauvegarder A quelque part puisque c'est lui qui contient le scan code à envoyer. Ensuite, il faut lire puis sauvegarder (par exemple dans la pile) la valeur de ksc_down_up, quoi que cette étape est peut-être facultative. Il faut ensuite mettre 0 dans ksc_down_up, puis récupérer le scan code, appeler usbkey_putkey, puis restaurer ksc_down_up (si nécessaire).

— PUSH sert à empiler une valeur sur la pile (donc à la sauvegarder) ;
— POP sert à dépiler une valeur et à la mettre dans le registre.

dpnc je ne peux pas simuler la touche shift sans passer par son scancode ?

L'appui sur Shift est considéré, en principe, par le PC comme un appui sur une touche normale. Le fait de modifier le bit devrait provoquer son envoi quand même par la routine d'envoi de rapport, mais on ne peut rien garantir.

[darkofmadness]

Merci !

Donc plutot comme ca :

Code :

1
2
3
4
5
6
7
8
9
10
11
 
	POP	A
	MOV	A,AT101KB_LEFTSHIFT
	call   usbkey_putkey
	MOV	A,AT101KB_RIGHTANGLE
	PUSH	A
	MOV	A,00h
	MOV	[ksc_down_up],A
	pop	A
	call   usbkey_putkey
	jmp  .tx_down_key_Fonction

Mais ca ne marche pas je crois
enfin je te remercie je vais devoir faire des tests, parce que je dois le finir aujourd'hui...

[Obsidian]

Il faut :

• Charger AT101KB_LEFTSHIFT puis appeler usbkey_putkey ;
• Charger AT101KB_RIGHTANGLE puis appeler usbkey_putkey ;
• Modifier ksc_down_up ;
• Charger à nouveau AT101KB_RIGHTANGLE puis appeler usbkey_putkey ;
• Charger à nouveau AT101KB_LEFTSHIFT puis appeler usbkey_putkey.

En principe (je dis bien « en principe ») ta routine devrait être capable de retomber sur ses pieds et de gérer correctement le moment où tu vas réellement relacher ces touches. Par contre, ça pourrait causer des problèmes dans le cas d'autres combinaisons, si d'autres touches sont enfoncées en même temps, dont la touche Shift ! Mais en principe ce cas ne devrait pas arriver.

[darkofmadness]

mais le problème aussi, c'est que si je sors pas de la boucle il n'envoie pas le code de la touche relachée !

Code :

1
2
3
4
5
 
	MOV	A,AT101KB_LEFTSHIFT
	call   usbkey_putkey
	MOV	A,AT101KB_RIGHTANGLE
	jmp  .tx_down_key_Fonction

ou jmp .tx_down_key_Fonction se rapporte à :

Code :

1
2
3
4
5
 
.tx_down_key_Fonction:
	mov	[ksc_last_transmit_caracter],A
	call   usbkey_putkey
	ret

La, par exemple, il envoie SHIFT appuyé, RIGHTANGLE appuyé, RIGHTANGLE relaché, et il boucle le code d'appui de SHIFT !

donc j'ai un peu de mal a comprendre comment faire et je cherche une solution qui fonctionne dans un premier temps, parce qu'après je me pencherais vraiment sur le problème

[Obsidian]

C'était à prévoir, malheureusement.

Tu commences à toucher du doigt le fond du problème : faire des palliatifs temporaires fonctionne jusqu'à un certain point, au delà duquel ce n'est plus possible. Le travail qu'on a reporté jusque là se rappelle à nous.

Il faudrait que l'on voie encore le reste du code avec tout la boucle principale, etc. pour être sûrs, mais ça commence à être un peu long, d'autant que j'ai mes propres obligations à côté.

Apparemment, ton programme tient la trace des touches enfoncées ou non à un moment t, en allouant un bit par modifier, un buffer pour les scan codes des six premières (ou dernières) touches ordinaires enfoncées, et un registre pour faire le compte total des touches réellement enfoncées même si l'on en a pas forcément la trace. Il semble également que ton programme dépose une consigne dans « usb_tx_required », probablement examinée à chaque nouveau tour de boucle et provoque l'envoi demandé.

Jette un œil au début de ta boucle principale à l'endroit où cette variable est traitée. Il y a probablement un appel CALL à la routine chargée de cette transmission. Si tu trouves, insère un seul appel juste après la ligne 5 (l'autre envoi se fera normalement en quittant ta procédure).

Il y a une chance sur deux pour que ça plante mais dans l'état actuel des choses, c'est le mieux que je puisse te proposer. Ça reste très sale, on est bien d'accord.