+ Répondre à la discussion
Page 2 sur 3 PremièrePremière 123 DernièreDernière
Affichage des résultats 21 à 40 sur 48
  1. #21
    Responsable Modération
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    septembre 2007
    Messages
    5 513
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2007
    Messages : 5 513
    Points : 14 171
    Points
    14 171

    Par défaut

    Citation Envoyé par darkofmadness Voir le message
    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.

  2. #22
    Invité de passage
    Homme Profil pro
    Responsable des études
    Inscrit en
    novembre 2012
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Responsable des études
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : novembre 2012
    Messages : 26
    Points : 3
    Points
    3

    Par défaut

    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?

  3. #23
    Responsable Modération
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    septembre 2007
    Messages
    5 513
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2007
    Messages : 5 513
    Points : 14 171
    Points
    14 171

    Par défaut

    Hello

    Citation Envoyé par darkofmadness Voir le message
    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.

  4. #24
    Invité de passage
    Homme Profil pro
    Responsable des études
    Inscrit en
    novembre 2012
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Responsable des études
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : novembre 2012
    Messages : 26
    Points : 3
    Points
    3

    Par défaut RE-Problème !

    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 !

  5. #25
    Responsable Modération
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    septembre 2007
    Messages
    5 513
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2007
    Messages : 5 513
    Points : 14 171
    Points
    14 171

    Par défaut

    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.

  6. #26
    Invité de passage
    Homme Profil pro
    Responsable des études
    Inscrit en
    novembre 2012
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Responsable des études
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : novembre 2012
    Messages : 26
    Points : 3
    Points
    3

    Par défaut

    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!)

  7. #27
    Responsable Modération
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    septembre 2007
    Messages
    5 513
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2007
    Messages : 5 513
    Points : 14 171
    Points
    14 171

    Par défaut

    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.

  8. #28
    Invité de passage
    Homme Profil pro
    Responsable des études
    Inscrit en
    novembre 2012
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Responsable des études
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : novembre 2012
    Messages : 26
    Points : 3
    Points
    3

    Par défaut

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

    Merci !

  9. #29
    Invité de passage
    Homme Profil pro
    Responsable des études
    Inscrit en
    novembre 2012
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Responsable des études
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : novembre 2012
    Messages : 26
    Points : 3
    Points
    3

    Par défaut

    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 !

  10. #30
    Responsable Modération
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    septembre 2007
    Messages
    5 513
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2007
    Messages : 5 513
    Points : 14 171
    Points
    14 171

    Par défaut

    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.

  11. #31
    Invité de passage
    Homme Profil pro
    Responsable des études
    Inscrit en
    novembre 2012
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Responsable des études
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : novembre 2012
    Messages : 26
    Points : 3
    Points
    3

    Par défaut

    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

  12. #32
    Responsable Modération
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    septembre 2007
    Messages
    5 513
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2007
    Messages : 5 513
    Points : 14 171
    Points
    14 171

    Par défaut

    Ç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.

  13. #33
    Invité de passage
    Homme Profil pro
    Responsable des études
    Inscrit en
    novembre 2012
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Responsable des études
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : novembre 2012
    Messages : 26
    Points : 3
    Points
    3

    Par défaut

    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.

  14. #34
    Responsable Modération
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    septembre 2007
    Messages
    5 513
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2007
    Messages : 5 513
    Points : 14 171
    Points
    14 171

    Par défaut

    Citation Envoyé par darkofmadness Voir le message
    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.

  15. #35
    Invité de passage
    Homme Profil pro
    Responsable des études
    Inscrit en
    novembre 2012
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Responsable des études
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : novembre 2012
    Messages : 26
    Points : 3
    Points
    3

    Par défaut

    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 !

  16. #36
    Responsable Modération
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    septembre 2007
    Messages
    5 513
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2007
    Messages : 5 513
    Points : 14 171
    Points
    14 171

    Par défaut

    Citation Envoyé par darkofmadness Voir le message
    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.

  17. #37
    Invité de passage
    Homme Profil pro
    Responsable des études
    Inscrit en
    novembre 2012
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Responsable des études
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : novembre 2012
    Messages : 26
    Points : 3
    Points
    3

    Par défaut

    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...

  18. #38
    Responsable Modération
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    septembre 2007
    Messages
    5 513
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2007
    Messages : 5 513
    Points : 14 171
    Points
    14 171

    Par défaut

    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.

  19. #39
    Invité de passage
    Homme Profil pro
    Responsable des études
    Inscrit en
    novembre 2012
    Messages
    26
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Responsable des études
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : novembre 2012
    Messages : 26
    Points : 3
    Points
    3

    Par défaut

    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

  20. #40
    Responsable Modération
    Avatar de Obsidian
    Homme Profil pro
    Chercheur d'emploi
    Inscrit en
    septembre 2007
    Messages
    5 513
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur d'emploi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2007
    Messages : 5 513
    Points : 14 171
    Points
    14 171

    Par défaut

    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.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •