Caractères Hexa en assembleur

[darkofmadness]

Bonjour à tous,
je suis nouveau sur ce forum et vraiment débutant en Assembleur.

J'ai une question, j'ai repris un programme pour faire fonctionner un clavier, je voudrais savoir comment je peux lui faire envoyer un caractère hexa (si c'est possible...) Par exemple, je fait Fn+8 il m'affiche @
Tout est géré, il ne me manque plus qu'a lui faire afficher le caractère !
(je suis vraiment nul en ASM ... )

En vous remerciant par avance !!

[Obsidian]

Bonjour,

• Sur quelle machine ?
• Avec quel système d'exploitation ?
• Et quel micro-processeur en particulier ?

L'assembleur n'est pas un seul langage unique normalisé mais est propre à chaque famille de micro-processeurs. Voir les règles du forum Assembleur : http://www.developpez.net/forums/d73...ulter-decrire/

A priori, tu travailles sur PC. Mais même là, la touche Fn n'est pas standardisée Il faut se pencher sur le mode de fonctionnement propre à chaque constructeur. Tu peux cependant te rabattre sur toutes les autres.

Pour le reste, si tu as repris un programme existant, poste-le ici (encadré par les balises [code] et [/code]), et on tâchera de t'aider.

[darkofmadness]

Merci de ta réponse !

je bosse sur PC en effet sur Windows XP,
le micro-processeur est un Cypress CY7C63413 (c'était bien la question?)
Le debugger est Cypress Debugger

Ensuite nous sommes spécialisé dans la fabrication de claviers industriels
La gestion de la touche Fn, de la combinaison avec une autre touche est OK. tout cela fonctionne, par exemple je sais faire Fn+8 me donne un A.
j'utilise ma table de de scancode.
voici un morceau du soft, j'espère que ce sera suffisant :

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
 
push	A
	CMP	A,T_FONCTION				;T_FONCTION
	jz	.Traite_T_FONCTION
	POP	A
 
	push	A                                              ; appui de la touche ESC
	CMP	A,AT101KB_ESCAPE
	jz	.ESCAPE
	POP	A
 
.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
 
.set_flag_T_FONCTION:
	MOV	A,01h
	mov	[ksc_flags],A
	jmp	.done_FoundKey
 
.ESCAPE:
	mov	A,[ksc_flags]
	cmp	a,0
	jnz	.KB_A
	POP	A
	call  ksc_putkey
	jmp .done_FoundKey 
 
.KB_A:
	POP	A
	MOV	A, AT101KB_A               ; envoie de la touche A
	call  ksc_putkey
	jmp .done_FoundKey  
 
.done_FoundKey:
	pop A                               ; restore accumulator
	ret                                 ; return

Et au lieu d'envoyer une touche de ma table je veux sois envoyer une combinaison, soit directement un code Hexa...

En espérant que c'est clair !
Merci par avance...

[Obsidian]

D'accord ! On fait bien de poser la question, parce que ça fait quand même beaucoup de détails qu'on ne connaissait pas. Je vais essayer de résumer la situation. Dis-moi si l'un de ces points est incorrect :

• Tu travailles sur un programme destiné à être implanté au final sur un micro-contrôleur CY7C63413 de Cypress. Tu utilises donc un PC pour écrire et compiler ton programme et probablement un émulateur-débogueur qui tourne sur le même PC pour le mettre au point, mais tu ne fais aucunement de la programmation pour PC ;
• Le clavier dont tu parles n'est absolument pas celui d'un PC, mais un modèle spécial à destination de machines industrielles ;
• À en voir l'étiquette « AT101KB_A », il semblerait que ton clavier spécial envoie malgré tout les scan codes originaux du clavier du PC AT 101 touches ;
• Le micro-contrôleur qui nous intéresse est probablement destiné à être intégré dans ledit clavier, ce qui veut dire que c'est le clavier lui-même que tu développes, et qu'il ne s'agit pas de faire en sorte que ton programme pilote un ordinateur pour que, lui, aille discuter avec le clavier qui lui est relié (comme on le ferait sur PC) ;
• Quand tu dis « je veux afficher », tu veux en fait faire en sorte que ton clavier envoie le bon code à son hôte (qui, lui, le traduira éventuellement en un écho à l'écran).

Tout ceci est-il correct ?

Tout d'abord, récupère la datasheet du produit que tu utilises, si tu ne l'as pas encore fait. La table des instructions reconnues par ton micro-contrôleur est en page 11 : http://www.alldatasheet.com/datashee...C63413-PC.html

Qu'entends-tu par « envoyer un code hexa » ? Est-ce que tu veux émettre un caractère spécial (tel que l'arobase) ou est-ce que tu veux réellement faire afficher à l'écran le code en hexadécimal, auquel cas il faudrait envoyer deux caractères consécutifs formant le code en question, comme si on l'avait tapé à la main ?

[darkofmadness]

Oh mais c'est parfait c'est exactement ca !
Excepté que les claviers sont spécifiques, mais peuvent très bien être utilisé comme un clavier bureautique (autrement ce sont des claviers durcis pour l'industrie mais fonctionne avec le même principe qu'un clavier standard, sauf bien sur la technologie mais hors sujet ici ^^)

Voila la base du problème c'est que quand je fais "Fn+8" (exemple) ca doit transmettre un "@". Or, comme vous le voyez dans le morceau du programme, si je met le scancode du "@" (AT101KB_00) je n'aurais pas "@" mais "à" qui va être transcrit.
J'étais parti donc sur la solution que je pensais la plus simple : à la place de l'étiquette, mettre un code hexa (ou ascii) pour sortir direcement le caractère @.
Parce que sinon a la place de l'étiquette il faudrait que je lui dise d'envoyer AltGr enfoncé puis AT101KB_00 et enfin relever AltGr et ça, bien entendu, je ne sais pas faire... (autant que la facon de faire pour ignorer l'état du CapsLock...)

J'espère que c'est assez clair !
Merci pour tout en tout cas

[Obsidian]

C'est plus compliqué que ça parce que ton étiquette n'est une « equate », c'est-à-dire un symbole associé à une valeur donnée, en l'occurence le scan code. Remplacer cette étiquette par une valeur exprimée en hexadécimal ne t'apportera rien car :

• Tu seras toujours obligé d'envoyer des scan codes à ton hôte. Tu ne pourras pas envoyer directement les codes ASCII des caractères qui t'intéressent ;
• Il faudra en plus que tu tiennes compte de la disposition simulée du clavier : agencement américain original, agencement français, belge, canadien, etc. A priori, de ce côté-là, il semble que tu utilises la disposition AT originale, donc en américain.

L'arobase, dans cet agencement, est sur la touche « 2 » : http://frontype.com/keyboarding/540p...oAltGr.svg.png

Il faudrait également vérifier la valeur de AT101KB_A et examiner la procédure ksc_putkey pour voir si A est censé contenir un scan code individuel ou un pointeur vers une série de scan codes.

D'une façon ou d'une autre, il te faudra donc envoyer la séquence « Shift + 2 ». Ça veut dire qu'il faudra envoyer le code d'appui sur « Shift », suivi du code d'appui sur « 2 » et enfin du code de relachement de « Shift », sinon tous tes caractères suivants seront considérés comme majuscules par l'hôte. Cette séquence est en fait elle-même composée d'un préfixe (0xF0) suivi du code de la touche relachée.

Ce n'est pas dur en soi : il suffit d'appeler quatre fois de suite ksc_putkey avec les bons codes, mais il faut d'abord explorer le programme pour voir si quelque chose de similaire n'a pas déjà été mis en place.

[darkofmadness]

Je te remercie (encore!) pour ta réponse claire.
mes etiquette sont bien des "equate" present dans un fichier nommé AT101.inc
(exemple dans ce fichier : AT101KB_A equ 05 ) le 05 est un exemple, je n'ai pas la valeur précise en tête.

Qu'entends tu par : le code d'appui de Shift ? c'est a dire AT101KB_LEFTSHIFT ?? ou sa valeur? et Pour le relachement je dois 0xf0 devant l'étiquette?


Je suppose que ca peut servir aussi, j'ai ces "equate" présents dans le programme :

Code :

1
2
3
4
5
6
7
8
9
 
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

Si je te comprends bien j'obtiens ca :

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
 
	push	A
	CMP	A,AT101KB_A
	jz	.KP2
	pop	A
 
.KP2:
	mov	A,[ksc_flags]
	cmp	a,0
	jnz	.AROBASE
	POP	A
	call  ksc_putkey
	jmp .done_FoundKey 
 
.AROBASE:
	POP	A
	MOV	A,AT101KB_RIGHTSHIFT
	call  ksc_putkey
	POP	A
	MOV	A,AT101KB_02
	call  ksc_putkey
	POP	A
	MOV	A,AT101KB_RIGHTSHIFT
	call  ksc_putkey
	jmp .done_FoundKey

[Obsidian]

Envoyé par darkofmadness

Qu'entends tu par : le code d'appui de Shift ? c'est a dire AT101KB_LEFTSHIFT ?? ou sa valeur? et Pour le relachement je dois 0xf0 devant l'étiquette?

Dans les faits, oui.
Peut-on voir les valeurs exactes de AT101KB_LEFTSHIFT et AT101KB_A pour voir si elles correspondent bien à ce que l'on est en droit d'attendre ?

Également, y a-t-il en soi une touche Shift ou un modificateur autre que Fn sur ton clavier, et es-tu déjà en mesure d'envoyer avec le logiciel existant un code qui nécessiterait un appui sur Shift ou assimilé sur le clavier d'un PC ?

[darkofmadness]

En fait, pour résumé, ces claviers ont un comportement identiques à un clavier bureautique. Si je fait "Shift+a", j'obtiens "A" ou encore "AltGr+à" j'obtiens "@"
Maintenant il y a autre chose (mais ce n'est qu'un détail), le layout (AZERTY, QWERTY etc...) importe peu : en effet le programme est identique quelquesoit la version du clavier.
Par conséquent pour être vraiment complet, quand je programme un clavier avec une organisation de touche en francais, dans le matricage (matrix.asm) je le prends en compte : AT101KB_Q va etre mis pour "A". C'est donc l'ordinateur qui va déterminer la sortie : AT101KB_Q sera un "Q" si on change la langue sur le PC mais sera un "A" si le PC est en francais.

Je ne sais pas si je m'explique bien.

Voici sinon une partie des valeurs des scancodes :

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
 
AT101KB_Q:                equ         17
AT101KB_W:                equ         18
AT101KB_E:                equ         19
AT101KB_R:                equ         20
AT101KB_T:                equ         21
AT101KB_Y:                equ         22
AT101KB_U:                equ         23
AT101KB_I:                equ         24
AT101KB_O:                equ         25
AT101KB_P:                equ         26
AT101KB_LEFTBRACKET:      EQU         27
AT101KB_RIGHTBRACKET:     EQU         28
AT101KB_VERTICAL_LINE:    EQU         29
AT101KB_CAPSLOCK:         EQU         30
AT101KB_A:                equ         31
AT101KB_S:                equ         32
AT101KB_D:                equ         33
AT101KB_F:                equ         34
AT101KB_G:                equ         35
AT101KB_H:                equ         36
AT101KB_J:                equ         37
AT101KB_K:                equ         38
AT101KB_L:                equ         39
AT101KB_SEMICOLON:         EQU         40
AT101KB_DOUBLEQUOTE:      EQU         41
AT101KB_NONUSPOUND:       EQU         42
AT101KB_ENTER:            EQU         43
AT101KB_LEFTSHIFT:        EQU         44

Maintenant dans keyscan.asm à aucun moment l'étiquette est remplacée par sa valeur.
On est donc bien d'accord que si on parle de AT101KB_LEFTSHIFT et AT101KB_A ce n'est que pour l'exemple?
Que ca sera le même principe avec AltGr par exemple?
Pour répondre à ta question mon soft est bien capable d'envoyer un code avec Shift appuyé.

[darkofmadness]

Un grand merci en tout cas Obsidian, j'en suis pas loin grace a ton aide !
J'ai juste une autre question mais il vaut mieux que je mette Resolu et que j'ouvre un autre poste?

[Obsidian]

En fait, pour résumé, ces claviers ont un comportement identiques à un clavier bureautique. Si je fait "Shift+a", j'obtiens "A" ou encore "AltGr+à" j'obtiens "@"

Ils ont un comportement identique, Ok, mais est-ce que, vu de l'utilisateur, ils ont également la même disposition (un peu comme les claviers pour montage vidéo) ou est-ce qu'extérieurement, il n'a rien à voir ?

C'est important parce qu'il n'y a pas de touche « @ » comme il y en a pour les lettres de l'alphabet : il faut faire une combinaison de touches pour saisir ce caractère et cette combinaison n'est pas la même selon les agencements : c'est « Shift + 2 » sur un clavier américain, mais c'est « AltGr + 0 » sur un clavier français. Et même là, « AltGr » est une touche relativement moderne qui n'existait pas sur les claviers à 84 touches (ok, ça commence à dater) et qui était souvent occupée par une seconde touche « Alt » sur les premiers claviers étendus. À l'époque, il fallait utiliser « Ctrl + Alt + Touche » pour obtenir le troisième caractère.

De là, trois possibilités :

1. Soit ton clavier est réellement un clavier de PC ordinaire, éventuellement agrémenté de fonctionnalités, et dans ce cas, ce n'est absolument pas lui qui doit gérer l'envoi de l'arobase : l'utilisateur appuie sur les touches qui portent le glyphe correspondant et l'hôte génère le caractère en fonction des scan codes reçus. Ton clavier n'a alors absolument pas notion d'envoyer en soi un « @ » plus qu'autre chose ;
2. Soit ton clavier a un agencement complètement différent de celui d'un PC et, dans ce cas, il faudra que tu simules la bonne séquence si tu veux donner la possibilité à ton utilisateur de saisir ce caractère. Et là, cette séquence dépend de l'agencement choisi sur l'hôte, lequel agencement doit alors être indiqué par ta compagnie ;
3. Soit encore tu considères que ton clavier est un modèle indépendant, au même titre que le Bépo ou le Dvorak. Dans ce cas, tu te ramènes au point numéro 1, mais cela t'oblige à fournir un gestionnaire de clavier pour le système d'exploitation que tu utilises.

Enfin, sois averti que le clavier d'un PC cache encore une subtilité : à lui, ne correspond pas un seul mais trois jeux de scan codes. Le plus courant aujourd'hui et celui qui est sélectionné par défaut est le numéro 2. La table que tu nous présentes correspond au premier jeu (historique). C'est toujours légal, mais il est possible que ça engendre des bugs difficiles à identifier sur certains systèmes, surtout s'ils sont industriels (donc généralement embarqués, volontairement minimalisés, souvent anciens et rarement mis à jour du fait de leur prix).

[Obsidian]

Envoyé par darkofmadness

Un grand merci en tout cas Obsidian, j'en suis pas loin grace a ton aide ! J'ai juste une autre question mais il vaut mieux que je mette Resolu et que j'ouvre un autre poste?

Si c'est en rapport de près ou de loin, tu peux l'ajouter ici. Si c'est très différent, ouvre une autre discussion.

Pose-la ici, je la déplacerai si nécessaire. :-)

[darkofmadness]

merci

Oui c'est un peu en rapport (meme soft)

En fait, je vais devoir inhiber le Capslock lors des combinaisons créer avec la touche Fn.
Par exemple si je fais Fn+F2 je dois sortir ">" j'ai donc mis Shift+< afin de passer en maj pour sortir le bon caractère, cependant en AZERTY si je fais cette combinaison et que le Capslock est activé, je vais me retrouver avec le caractère "<" (contrairement au QWERTY qui ne "s'occupe" pas du Capslock. Ex si j'appuis sur la touche "2" au dessus du "W" on sort un 2 que l'on soit en maj ou non.)
J'ai donc besoin d'ignorer le Capslock. ou du moins de le désactiver le temps de l'appui non?

Merci a toi pour ton aide si précieuse

Je vais tester de suite ce que j'ai fais deja.

[Obsidian]

Envoyé par darkofmadness

En fait, je vais devoir inhiber le Capslock lors des combinaisons créer avec la touche Fn. Par exemple si je fais Fn+F2 je dois sortir ">" j'ai donc mis Shift+< afin de passer en maj pour sortir le bon caractère, cependant en AZERTY si je fais cette combinaison et que le Capslock est activé, je vais me retrouver avec le caractère "<" (contrairement au QWERTY qui ne "s'occupe" pas du Capslock. Ex si j'appuis sur la touche "2" au dessus du "W" on sort un 2 que l'on soit en maj ou non.)
J'ai donc besoin d'ignorer le Capslock. ou du moins de le désactiver le temps de l'appui non?

Le problème est que Caps Lock, comme Shift, n'est pas géré par le clavier lui-même mais par l'hôte. Et il faudra que tu en tiennes compte si tu conçois un clavier spécial censé fonctionner en environnement standard. Les LED du clavier sont pilotées par le logiciel du PC à sa convenance. C'est d'ailleurs pour cela qu'elles se figent lorsque ton PC plante. Ensuite, l'appui sur Caps Lock est géré comme un appui sur un touche normale et c'est l'hôte qui décide de rentrer ou sortir dans un mode spécial et, éventuellement, de piloter la LED en conséquence.

Il faut absolument garder à l'esprit que, quoi qu'il se passe, un clavier n'envoie toujours que des scan codes et jamais des caractères.

Ça signifie que si tu dois envoyer malgré tout « @ », tu serais obligé de garder en mémoire l'état de Caps Lock en espérant que l'hôte n'ait pas manqué une trame. Ou alors t'appuyer sur l'état de la LED mais même ça, ce n'est pas fiable à 100 %. Surtout qu'il y a plusieurs moyens de gérer Caps Lock : les anglo-saxons utilisent cette touche comme une bascule qui passe d'un état à l'autre chaque fois que l'on appuie dessus, alors que les européens verrouillent les majuscules avec Caps, et repassent en minuscules avec Shift (ce qui est le comportement des machines à écrire mécaniques).

Pour le reste, relis bien mon commentaire numéro 11.

[darkofmadness]

Merci ! (je m'en lasse pas^^)

Autant pour moi, je n'avais pas vu ton commentaire 11.
C'est donc la possiblité n°2 !
Mais saches que la base du soft ne change jamais ! que j'ai un clavier etendu 103touches, ou un clavier compact 80 touches, je modifie (pour un clavier simple, c'est à dire sans touche Fn) uniquement la table de matrice (matrix.asm)

De plus, pour notre clavier standard 105touches, qu'il soit en AZERTY, QWERTY ou autre ne change rien du tout ! il fonctionne de la meme manière (c'est a dire qu'en AZERTY j'enverrais un A alors qu'en QWERTY j'enverrais un Q; tout ca avec le meme soft)

Ensuite, je pars du principe que le clavier que je suis en train de developper, sera en AZERTY uniquement c'est un layout spécifique pour le client, si un jour il veut en QWERTY je changerais mon soft, pas de soucis.

Donc, sur la base Francaise, lors de mon appui Fn+2, je lui envois AltGr+0 :

Code :

1
2
3
4
5
6
7
8
 
.AROBASE:
	POP	A
	MOV	A,AT101KB_RIGHTALT
	call  ksc_putkey
	MOV	A,AT101KB_00
	call  ksc_putkey
	jmp .done_FoundKey

C'est bon ca?

Maintenant, j'envois "%" lorsque j'appuies sur Fn+5 :

Code :

1
2
3
4
5
6
7
8
 
.PRCENT:
	POP	A
	MOV	A,AT101KB_LEFTSHIFT
	call  ksc_putkey
	MOV	A,AT101KB_DOUBLEQUOTE
	call  ksc_putkey
	jmp .done_FoundKey

Mais si le Capslock est activé, ce n'est pas "%" mais "ù" qui va s'afficher étant donné que j'envoie des scancodes.
On en vient a ma question, comment faire pour gérer l'état du Capslock?
Si je le rajoute dans l'envoi, et qu'il n'est pas actif, il va s'activer !

*marre*

[Obsidian]

Envoyé par darkofmadness

Mais saches que la base du soft ne change jamais ! que j'ai un clavier etendu 103touches, ou un clavier compact 80 touches, je modifie (pour un clavier simple, c'est à dire sans touche Fn) uniquement la table de matrice (matrix.asm)

J'entends bien, mais ça veut quand même dire qu'à la base, dans sa disposition des touches (avant de se pencher sur ce qui est dessiné dessus), le modèle de ton clavier est quand même un 105 touches standard.

C'est important parce que ça aurait pu être n'importe quoi d'autre, typiquement un produit de ce genre mais néanmoins conçu pour émettre les scan codes d'un clavier de PC, pour que l'on puisse directement piloter des appareils sans logiciel particulier.

C'est aussi le cas des douchettes à codes-barres qui sont faites pour s'intercaler en série sur le port PS/2 et qui, lors d'un scan, renvoient directement le numéro correspondant comme si on l'avait tapé au clavier. Ce qui est d'ailleurs très appréciable puisque ça permet à l'opérateur de réellement le faire lorsque la lecture est impossible. Avec ces appareils, il n'y a pas de touche du tout ! :-) Et pourtant, ils envoient quand même bien des scan codes.

De plus, pour notre clavier standard 105touches, qu'il soit en AZERTY, QWERTY ou autre ne change rien du tout ! il fonctionne de la meme manière (c'est a dire qu'en AZERTY j'enverrais un A alors qu'en QWERTY j'enverrais un Q; tout ca avec le meme soft)

Oui, mais il est nécessaire d'être très clair sur ce point car c'est lui qui va définir ta ligne de conception : en gros, le layout est imprimé sur ton clavier, donc même si tu sors éventuellement d'autres modèles (en changeant matrix.asm), tu ne peux pas changer l'agencement d'un exemplaire donné : donc tu vas embarquer un firmware correspondant à cet agencement. Et c'est parce que l'un comme l'autre sont immuables que tu vas te permettre d'envoyer la séquence française depuis un clavier français, et la séquence américaine depuis un clavier américain.

Ce qui serait beaucoup plus propre en revanche, c'est d'associer son propre scan code à ta touche Fn et de fournir un pilote pour l'ordinateur hôte. Ça résoudrait tous tes problèmes, y compris de compatibilité descendante, et ça permettrait à ton clavier de fonctionner malgré tout comme un clavier ordinaire si le pilote n'est pas installé. C'est faisable, il y a de la place, mais la norme ne prévoit pas, à ma connaissance, de scan code « réservé » pour un usage utilisateur. Ce n'est pas forcément très grave.

Donc, sur la base Francaise, lors de mon appui Fn+2, je lui envois AltGr+0 :

Code :

C'est bon ca?

Il faut aussi que tu émettes le code de relachement de la touche Alt, sinon toutes les autres touches émises par la suite seront considérées comme « altées » par le PC hôte. Et, en principe, tu devrais gérer le code de relachement pour toutes les touches. Examine ton soft pour voir s'il ne le fait pas déjà. C'est important.

Mais si le Capslock est activé, ce n'est pas "%" mais "ù" qui va s'afficher étant donné que j'envoie des scancodes. On en vient a ma question, comment faire pour gérer l'état du Capslock? Si je le rajoute dans l'envoi, et qu'il n'est pas actif, il va s'activer !

*marre*

C'est ce que je t'explique dans mon commentaire 14. Tu ne peux pas savoir si tu es en mode Caps Lock ou non puisque c'est l'hôte qui gère cela. La chose la plus fiable — sans l'être à 100 % — est d'examiner l'état de la LED Caps Lock qui est pilotée par le PC.

Et encore, même là, ce n'est pas forcément ce qu'il faut faire à tout prix : sur clavier français, le Caps Lock n'est pas forcément synonyme de Shift : AltGr avec Caps Lock actif n'est pas l'équivalent de de « AltGr + Shift ». Et de toutes façons, cela se paramètre au niveau logiciel. Sous Windows, c'est relativement statique mais il y a quand même des options d'accessibilité qui modifient tout cela. Sous Linux, la correspondance scan code ↔ caractère peut être modifiée à volonté par l'utilisateur et les systèmes comme iBus et le système de saisie de Gnome permettent de passer plein d'options pour « régionaliser » le comportement du clavier.

C'est ce qui se passe lorsqu'on se fait imposer par sa hiérarchie des concepts apparemment simples et qui trahissent en fait de grosses faiblesses dans la conception même, surtout lorsqu'on ne peut y déroger.



Et enfin, la grande question : pourquoi as-tu besoin de faire cela ? Tu comprends bien que si tu envoies « @ » en faisant « Fn + 8 », l'utilisateur pourra tout autant saisir le même caractère en tapant « AltGr + 0 » et ni le PC, ni ton clavier ne seront capables de faire la différence entre les deux (à moins que ton clavier soit dépourvu de touche AltGr).

[darkofmadness]

salut et encore merci pour ton temps.

Je ne suis pas sur que tu ai tout compris :

Regarde :

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
 
		XPAGEOFF
p02_to_at101_tbl:
;cOLONNE 0 ET L0 à L7
 
    db           AT101KB_ESCAPE,AT101KB_TAB,AT101KB_CAPSLOCK,AT101KB_LEFTSHIFT
    db           AT101KB_LEFTCTRL,0,0,0
 
;cOLONNE 1 ET L0 à L7
 
    db           AT101KB_F1,AT101KB_Q,AT101KB_A,AT101KB_Z
    db           AT101KB_LEFTALT,0,0,0
 
;cOLONNE 2 ET L0 à L7
 
    db           AT101KB_F2,AT101KB_W,AT101KB_s,AT101KB_x
    db           T_FONCTION,0,0,0
 
;cOLONNE 3 ET L0 à L7
 
    db           AT101KB_F3,AT101KB_E,AT101KB_D,AT101KB_C
    db           AT101KB_DELETE_FORWARD,0,0,0
 
;cOLONNE 4 ET L0 à L7
 
    db           AT101KB_F4,AT101KB_R,AT101KB_F,AT101KB_V 
    db           AT101KB_SPACE,0,0,0
 
;cOLONNE 5 ET L0 à L7
 
    db           AT101KB_F5,AT101KB_T,AT101KB_G,AT101KB_B 
    db           AT101KB_UNDERSCORE,0,0,0
 
;cOLONNE 6 ET L0 à L7
 
    db           AT101KB_F6,AT101KB_Y,AT101KB_H,AT101KB_N 
    db           AT101KB_NONUSPOUND,0,0,0
 
;cOLONNE 7 ET L0 à L7
 
    db           AT101KB_F7,AT101KB_U,AT101KB_J,AT101KB_M
    db           AT101KB_APPLICATION,0,0,0
 
;cOLONNE 8 ET L0 à L7
 
    db           AT101KB_F8,AT101KB_I,AT101KB_K,AT101KB_QUESTION
    db           AT101KB_LEFTARROW,0,0,0
 
;cOLONNE 9 ET L0 à L7
 
    db           AT101KB_F9,AT101KB_O,AT101KB_L,AT101KB_UPARROW
    db           AT101KB_DOWNARROW,0,0,0
 
;cOLONNE 10 ET L0 à L7
 
    db           AT101KB_F10,AT101KB_P,AT101KB_ENTER,AT101KB_SCROLL_LOCK
    db           AT101KB_RIGHTARROW,0,0,0
 
;cOLONNE 11 ET L0 à L7
 
    db           AT101KB_F11,AT101KP_NUMLOCK,0,0 
    db           0,0,0,0 
 
;cOLONNE 12 ET L0 à L7
 
    db           AT101KB_F12,AT101KP_7,AT101KP_4,AT101KP_1 
    db           AT101KP_0,0,0,0
 
;cOLONNE 13 ET L0 à L7
 
    db           AT101KB_DELETE,AT101KP_8,AT101KP_5,AT101KP_2
    db           AT101KP_PERIOD,0,0,0
 
;cOLONNE 14 ET L0 à L7
 
    db           AT101KP_9,AT101KP_6,AT101KP_3,AT101KP_ENTER
    db           0,0,0,0
 
;cOLONNE 15 ET L0 à L7
 
    db          0,0,0,0
    db          0,0,0,0
 
;cOLONNE 16 ET L0 à L7
 
    db          0,0,0,0
    db          0,0,0,0
 
;cOLONNE 17 ET L0 à L7
 
    db          0,0,0,0
    db          0,0,0,0
 
;cOLONNE 18 ET L0 à L7
 
    db          0,0,0,0
    db          0,0,0,0
 
;cOLONNE 19 ET L0 à L7
 
    db          0,0,0,0
    db          0,0,0,0

Tu vois, si j'ai moins de touches, je mets des 0, donc, sur une clavier "basique" (j'appelles basique, un clavier qui ne possède pas de touche Fn, peut importe le nombre de touches) j'aurais uniquement ca à changer !

J'en reviens donc a ta suggestion, si je fais ca, c'est que je devais faire un clavier le plus compact possible (AZERTY 71 touches avec pavé numérique !) c'est pourquoi j'ai du placer une touche Fn pour les caractères spéciaux !
Concernant le relachement, il est deja geré par le firmware, mais en fait quand on fait AltGr+0 il me sors : Appui AltGr, Appui 0, Relachement 0 et relachement AltGr. Maintenant avec le bout de soft que je t'ai montrer plus haut, lorsque je fait Fn+2 il simule : Appui AltGr, Appui 0 (normal jusque la), Relachement AltGr et relachement 0 (il inverse les deux relachements, je sais pas si ca peut poser un probleme?

Pour le Capslock, j'ai fait ca : (qui ne marche pas, mais tu pense que je pourrais m'en approcher?)

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
.DEUXPTS:
	POP	A
	MOV	A,CAPS_LOCK_LED
	cmp	A,0
	jz .DPTS
	POP	A
	MOV	A,AT101KB_RIGHTANGLE
	call  ksc_putkey
	jmp .done_FoundKey  
 
.DPTS:
	POP	A
	MOV	A,AT101KB_LEFTSHIFT
	call  ksc_putkey
	MOV	A,AT101KB_RIGHTANGLE
	call  ksc_putkey
	jmp .done_FoundKey

Je te remercie

[Obsidian]

Hello,

Envoyé par darkofmadness

J'en reviens donc a ta suggestion, si je fais ca, c'est que je devais faire un clavier le plus compact possible (AZERTY 71 touches avec pavé numérique !) c'est pourquoi j'ai du placer une touche Fn pour les caractères spéciaux !

C'est cela que je cherche à savoir depuis le départ.

À en voir ta matrice, tu développes un clavier matriciel à quinze colonnes et à cinq lignes, soit un maximum de 75 touches (et en l'occurrence 71). Et donc, effectivement, pas du tout une disposition de PC.

Maintenant avec le bout de soft que je t'ai montrer plus haut, lorsque je fait Fn+2 il simule : Appui AltGr, Appui 0 (normal jusque la), Relachement AltGr et relachement 0 (il inverse les deux relachements, je sais pas si ca peut poser un probleme?

Ce n'est pas génial, en effet, mais ça devrait passer.

Par contre, es-tu sûr que c'est bien dans cet ordre que tes séquences sont envoyées et pas « Appui sur AltGr ; Relachement de AltGr ; Appui sur 0 ; Relachement de 0 ; » ? Je demande cela parce qu'on ne sait pas comment fonctionne ta routine clavier. Il se peut qu'elle conserve une trace de toutes les touches « enfoncées » pour les relacher ensuite à une autre position de ton programme. Mais j'ai le sentiment que les codes que tu nous montres à ton commentaire numéro 7 servent en fait à ça et devraient être passés d'une manière ou d'une autre à la routine au moment de l'émission d'une touche.

Pour le reste, tu simules un layout de PC qui ne correspond pas à ton clavier réel. Il faut donc que tu en choisisse un arbitrairement sur le PC et que tu t'y tiennes de ton côté. Apparemment, tu as choisi l'AZERTY français ordinaire. En principe, dans les configurations les plus courantes, « AltGr » n'est pas sensible au Caps Lock. Un « AltGr + 0 » devrait donc se traduire en « @ » dans tous les cas. Mais comme dit plus haut, ce n'est qu'une politique du système d'exploitation, qui peut facilement changer.

Pour « > », avec « Shift + < », ma distribution de Linux ne tient pas compte non plus du Caps Lock ! En fait, elle ne l'applique qu'aux lettres, susceptibles d'être écrites en majuscules. Donc ça change selon les layouts et les systèmes d'exploitation.

Pour le Capslock, j'ai fait ca : (qui ne marche pas, mais tu pense que je pourrais m'en approcher?)

Code :

Je te remercie

Dans le principe, ça pourrait y ressembler mais on ne sait pas à quoi sert CAPS_LOCK_LED. Est-ce un registre mémoire utilisé pour y déposer un flag ? Est-ce un port I/O qui la pilote directement (et, dans ce cas, est-il accessible en lecture, et contient-il éventuellement d'autres informations) ou est-ce un flag tels que les codes du commentaire #7 ?


Je suppose que le PC hôte fonctionne sous Windows. Même si le produit est probablement déjà en production sous une forme quelconque et que beaucoup de travail a déjà été fait par tes prédécesseurs, je t'encourage plutôt à développer un descripteur de clavier à l'intention du système d'exploitation. Ce sera plus facile et tu pourras alors gérer toutes tes touches de la façon qui t'intéresse sans avoir à recourir à ce genre d'artifice.

[darkofmadness]

Je ne suis pas assez bon developpeur pour recommencer tout à zéro !
Et comme on dit : on ne change pas une équipe qui gagne ^^ (ce soft est utilisé depuis plus de dix ans me semble-t-il ^^)

Concernant AltGr, en effet il ne tient pas compte du CapsLock, cependant le Shift oui. Et je fais les caractères spéciaux, par exemple ":". Quand le capslock est actif je me retrouve donc avec "/"

Je suis désolé mais je vais te mettre tout ce que j'ai trouvé sur les commandes des LEDs :
dans portdef.inc (définition des ports quoi ) :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
; LED and KEY bit masks in port 3
;£££££££££££££££££££££££££££££££££££££
P3_KEY_MASK:		    equ	30h	; bits[5:4]
;£££££££££££££££££££££££££££££££££££££
 
P3_LED_MASK:		    equ	07h	; bits[2:0]
 
;£££££££££££££££££££££££££££££££££££££
P3_KEY_LSBIT_MASK:      equ 010h ; first bit of key drive lines in p3
;£££££££££££££££££££££££££££££££££££££
 
P3_USB_CONN_MASK:       equ 08h; usb connection bit
 
; LED positions in port 3
NUM_LOCK_LED:     	    equ	   1h  ; bit[0]
CAPS_LOCK_LED:          equ    2h   ; bit[1]
SCROLL_LOCK_LED:        equ    4h   ; bit[2]
 
; Normal GPIO port configuration
NORMAL:			equ	f5h	    ; Port3 resistive neg
				      	    ; Port2 resistive neg
					        ; Port1 open drain neg

Dans keyscan j'ai une fonction qui, me semble-t-il, permet l'ecriture (je ne veux pas ecrire cependant, mais tester l'état) :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
; The three LEDs are on port 3 bits[2:0]
 
ksc_writeLED:
    push  A
    mov A,[ksc_p3out]
	and A, ~P3_LED_MASK
    mov [ksc_p3out],A
    pop A
    cpl A
    and A,P3_LED_MASK
    or A,[ksc_p3out]
    mov [ksc_p3out],a
	iowr PORT3_DATA_REG
    ret

dans usbmain.asm (le principal me semble-t-il ^^) j'ai une table mais je vois pas trop a quoi ca correspond :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
;table to translate usb-command enumeration of leds into our own bits
XPAGEOFF
usb_led_tbl:
    db  0
    db  NUM_LOCK_LED
	db	CAPS_LOCK_LED
    db  NUM_LOCK_LED + CAPS_LOCK_LED
    db  SCROLL_LOCK_LED
    db  SCROLL_LOCK_LED + NUM_LOCK_LED
    db  SCROLL_LOCK_LED + CAPS_LOCK_LED
    db  SCROLL_LOCK_LED + NUM_LOCK_LED + CAPS_LOCK_LED	
 
XPAGEON

Dans les registres (regs.inc) j'ai des equate du port 3 (ports des LEDs) :

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
 
; I/O ports
Port0_Data:           	equ   00h	; GPIO data port 0
Port1_Data:           	equ   01h	; GPIO data port 1
Port2_Data:	      	equ   02h	; GPIO data port 2
Port3_Data:			equ   03h	; GPIO data port 3
 
Port0_Interrupt:       	equ   04h	; Interrupt enable for port 0
Port1_Interrupt:       	equ   05h	; Interrupt enable for port 1
Port2_Interrupt:		equ   06h	; Interrupt enable for port 2
Port3_Interrupt:		equ   07h	; Interrupt enable for port 3
 
[...]
PORT0_DATA_REG:             equ   00h   ; GPIO data port 0
PORT1_DATA_REG:             equ   01h   ; GPIO data port 1
PORT2_DATA_REG:             equ   02h       ; GPIO data port 2
PORT3_DATA_REG:             equ   03h     ; GPIO data port 3
 
PORT0_INTERRUPT_REG:        equ   04h   ; Interrupt enable for port 0
PORT1_INTERRUPT_REG:        equ   05h   ; Interrupt enable for port 1
PORT2_INTERRUPT_REG:        equ   06h     ; Interrupt enable for port 2
PORT3_INTERRUPT_REG:        equ   07h     ; Interrupt enable for port 3
 
GPIO_CONFIG_REG:            equ   08h     ; General purpose I/O configuration

Voila je crois que j'ai rien oublié, et que c'est pas trop brouillon !

Au vue de ces infos, tu sais comment je peux tester cette foutue LED ?

[darkofmadness]

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

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
.DEUXPTS:
	Push	A
	MOV	A,[ksc_p3out]
	AND 	A,%00000010
	CMP	A,CAPS_LOCK_LED
	JZ .DPTS
	POP	A
	MOV	A,AT101KB_LEFTSHIFT
	call  ksc_putkey
	MOV	A,AT101KB_RIGHTANGLE
	call  ksc_putkey
	jmp .done_FoundKey  
 
.DPTS:
	POP	A
	MOV	A,AT101KB_RIGHTANGLE
	call  ksc_putkey
	jmp .done_FoundKey

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