Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Dossier : Le fonctionnement du clavier sur AmigaOS
(Article écrit par Loïc Far et extrait d'Amiga News Tech - octobre 1991)
|
|
De toutes les interfaces de l'Amiga, le clavier est sans aucun doute la plus utilisée, juste après
la souris. Pourtant, peu de programmeurs savent comment il fonctionne et comment l'utiliser efficacement.
Avec un peu de bonne volonté, on peut facilement réaliser une routine de gestion du clavier qui soit en total
accord avec les conseils des créateurs de l'Amiga. Nombre de démos et de jeux utilisent des routines toutes
faites dont le seul travail consiste à lire un octet à une adresse donnée, pour savoir quelle touche a été
appuyée. Ce procédé fonctionne et a le mérite d'être simple. Il n'est toutefois pas très sûr et l'on peut
"manquer" plusieurs touches sans même s'en rendre compte.
Généralités
Le clavier des Amiga 500 et 2000 a 96 touches et fait partie de cette catégorie de claviers dits "intelligents",
car il possède son propre microprocesseur, en l'occurrence un 6500/1, de la famille du 6502.
Il s'agit d'un microprocesseur 8 bits disposant de sa propre ROM (2 ko) qui décharge le 68000
de tout le travail fastidieux de reconnaissance de la ou des touches appuyées. Le processeur central
reste toutefois obligé de capturer cette touche dans un tampon mémoire et de transmettre l'information
adéquate aux différentes applications concernées (en l'occurrence, le keyboard.device, qui lui-même
transmet l'information à l'input.device, qui lui-même la transmet à Intuition et au console.device. Ouf !).
Le clavier émet deux signaux, l'un unidirectionnel (du clavier vers l'Amiga), l'autre bidirectionnel
(communication possible dans les deux sens) : il s'agit de KDAT et de KCLK. KDAT est relié au port
série du CIA A (registre SP, adresse $BFEC01) ; c'est à travers lui que le 68000 pourra lire le code
clavier envoyé). KCLK est relié à la broche CNT de ce même CIA (registre ICR, adresse $BFEE01,
bit 6). Revoyez au besoin mon article sur les CIA.
Le transfert des données
Le schéma de communication est alors le suivant : le clavier met KLCK et KDAT à l'état haut
(rappel : ces deux signaux sont actifs à l'état bas). Il commence la transmission en mettant
le premier bit de donnée sur KDAT, suivi d'une pulsation sur KLCK (bas puis haut). Le second bit
de donnée est alors envoyé, suivi d'une nouvelle pulsation, et ainsi de suite jusqu'au huitième
bit (pour information, la transmission d'un bit dure exactement 60 microsecondes, pulsation comprise ;
de fait, la vitesse de transmission est de 17 kbits par seconde). Lorsque tous les bits ont été
envoyés et la dernière pulsation émise, le clavier remet KDAT à l'état haut. Ce n'est également
que lorsque les huit bits ont été reçus, c'est-à-dire lorsque son port série est plein, que le
CIA A déclenche une interruption de niveau 2. A partir de là, c'est au 68000 de jouer.
La première chose que le microprocesseur doit faire (juste après avoir lu le caractère, bien sûr),
c'est signaler au clavier la bonne réception de ce caractère. Cela se fait en mettant KDAT à
l'état bas pendant au moins 1 microseconde, puis de nouveau à l'état haut. Si l'on en croît les
recommandations du Hardware Manual, 1 microseconde est un délai minimal que seuls les meilleurs
claviers (entendez par là ceux disposant des meilleurs composants) pourront détecter ; le
logiciel doit émettre le signal de contact ("handshake") pendant au moins 85 microsecondes pour être totalement
compatible avec tous les modèles de clavier passés, présents ou futurs.
Le clavier attend ce signal de contact pendant un maximum de 145 millisecondes. Si passé ce
délai il n'a pas reçu le signal, il considère que la transmission a raté et entre dans
un mode spécial de correction d'erreur. Ce mode consiste à émettre des 1 à espaces réguliers
de 145 millisecondes sur KDAT jusqu'à ce qu'enfin, le signal arrive. Une fois la ligne rétablie,
un faux caractère aura été transmis à l'ordinateur, qui n'aura entre temps reçu que des 1 (nous
verrons un tout petit peu plus loin que cela ne prête absolument pas à conséquence et comment
les ingénieurs de chez Commodore Amiga ont résolu le problème). Le clavier envoie alors un
code spécial ($F9) à l'Amiga pour lui signaler que le précédent caractère était erroné et que le
même va être retransmis. Notez que ce code n'aide en rien à la resynchronisation des deux processeurs ;
il avertit seulement le logiciel système qu'une erreur est survenue. Le clavier pourrait tout aussi
bien retransmettre le caractère fautif sans rien dire à personne.
Le format des données
Nous l'avons vu, les données du clavier sont émises en série vers le CIA A. Les codes clavier
sont codés sur 7 bits seulement (valeurs de $00 et $7F, soit de 0 à 127 en décimal),
ce qui est amplement suffisant. Le huitième bit est employé comme drapeau pour indiquer si
la touche concernée a été enfoncée (0) ou relâchée (1). En effet, lorsque l'on appuie sur
une touche, par exemple une lettre, cela suppose deux actions : d'abord l'enfoncer, puis la
relâcher. Le clavier distingue ces deux actions afin de limiter le nombre de transferts vers
l'ordinateur lorsqu'une touche est maintenue enfoncée pendant longtemps. Dans tous les cas,
les bits 7 à 1 de l'octet reçu par le CIA contiendront le code clavier effectif et le bit 0,
le drapeau KEY UP/KEY DOWN. Quand le 68000 aura lu cet octet sur le port série, il devra donc lui
faire subir une rotation d'un bit vers la droite (à l'aide de l'instruction ROR) afin de
reconstituer le véritable code clavier. Le drapeau se retrouvera quant à lui dans le bit 7.
Seule la touche Verrouillage Majuscule fait exception à cette règle ; le clavier n'envoie de
code la concernant que lorsqu'elle a été enfoncée. Au premier appui sur cette touche,
le clavier envoie son code avec le drapeau KEY UP à 0. L'Amiga sait donc que cette touche vient
d'être activée (entre temps, le clavier aura également allumé la LED de la touche). Au second
appui sur Verrouillage Majuscule, le clavier envoie son code avec cette fois-ci le drapeau
KEY UP à 1. La LED s'éteint et l'Amiga sait que Verrouillage Majuscule n'est plus active.
En cela, Verrouillage Majuscule agit exactement comme si l'on maintenait une touche Shift
enfoncée pendant longtemps. Ce qui serait évidemment bien moins pratique.
La raison du prédécalage du code caractère par le clavier réside justement dans le protocole
de correction d'erreur vu plus haut : dans ce mode, le clavier n'envoie que des 1 à l'Amiga,
jusqu'à ce qu'il reçoive le signal de contact. De fait, lorsque la communication sera
rétablie, l'Amiga croira avoir à faire à une touche relâchée (le dernier bit étant à 1, vous
suivez encore ?), ce qui est beaucoup moins grave que s'il pensait avoir à faire à une touche enfoncée.
N'oubliez pas enfin que la ligne KDAT est active à l'état bas, c'est-à-dire qu'un 1 reçu
correspond en fait à un 0 et inversement. Pour palier à cela, le 68000 devra inverser chaque
bit du code reçu avant de réellement pouvoir l'exploiter. Ceci est réalisé très simplement par
une simple instruction NOT.
Codes spéciaux
Le clavier transmet quelques codes spéciaux à l'Amiga, qui ne sont pas des numéros de
touches, pour lui signaler un état particulier. Nous en avons déjà vu un exemple avec le code $F9,
qui signifie que la synchronisation entre les deux processeurs a été perdue. Il en existe d'autres,
que voici réunis dans la liste ci-dessous.
- $78 : avertissement de réinitialisation. Le clavier signale ainsi à l'Amiga que les touches
"Ctrl-Amiga Gauche-Amiga Droite" ont été pressées simultanément.
- $F9 : erreur de synchronisation.
- $FA : le tampon mémoire de caractères du clavier est plein.
- $FB : inutilisé.
- $FC : l'auto-test du clavier a échoué.
- $FD : début de séquence PowerUp. Le clavier transmet à l'Amiga tous les codes clavier qu'il a
enregistrés pendant son initialisation, et qu'il ne pouvait donc pas encore émettre.
- $FE : fin de séquence PowerUp.
- $FF : inutilisé.
Le code $78 n'est malheureusement plus en vigueur depuis longtemps. Sur les premiers A1000,
il était envoyé à l'Amiga pour lui signaler que l'utilisateur avait demandé une réinitialisation.
Après s'être acquitté d'un protocole de réponse particulier, l'Amiga disposait alors de 10
secondes de répit pour se préparer à la réinitialisation, c'est-à-dire principalement terminer
tous les accès disques en cours. Au terme de ces 10 secondes, le clavier réinitialisait l'ordinateur.
Ceci n'est plus possible depuis l'apparition des A500 et A2000.
Les codes $FC, $FD et $FE sont envoyés suivant le résultat de l'auto-test auquel le clavier se
soumet à chaque réinitialisation. Ce test inclut une somme de contrôle de sa ROM et de sa mémoire
(celle qui contient le tampon mémoire de caractères et les variables de son programme) et une
vérification de son chronomètre. Une fois ce test effectué, il essaye d'entrer en synchronisation
avec l'Amiga suivant la procédure décrite plus haut. Ce n'est qu'une fois synchronisé qu'il envoie à
l'Amiga le résultat de son test. Si celui-ci a été négatif, le code $FC est envoyé et le clavier
fait clignoter la LED de la touche Verrouillage Majuscule suivant un protocole défini ainsi :
- Un clignotement : la somme de contrôle de la ROM est incorrecte.
- Deux clignotements : la somme de contrôle de la mémoire est incorrecte.
- Trois clignotements : le chronomètre ne fonctionne pas correctement.
Après ceci, le clavier tente de se réinitialiser. L'Amiga quant à lui peut très bien fonctionner
sans clavier ; ce code ne sert qu'à l'informer que celui-ci n'est pas en état de travailler.
Si au contraire son auto-test est positif, le clavier transmet à l'Amiga tous les codes des touches
qui auraient pu être appuyées durant son initialisation. Cela commence par le code spécial $FD,
suivi des codes avec tampon mémoire sans prendre en compte leur relâchement. En d'autres termes, tous ces
codes sont envoyés avec le drapeau KEY UP à 0 (touche enfoncée). Finalement, le clavier conclut cette
série par un second code spécial, $FE.
Il est très peu probable qu'une touche soit appuyée avant que le clavier
n'ait eu le temps de faire son auto-test et de se synchroniser avec l'ordinateur.
De fait, la séquence typique de démarrage du clavier sera (en assumant que tout fonctionne correctement) :
1) Initialisation interne.
2) Synchronisation avec l'ordinateur.
3) Transmission de $FD.
4) Transmission de $FE.
Dans tous les cas, $FD et $FE sont transmis, même si aucune touche n'a été pressée.
Les codes clavier
Je vous propose une double liste des codes clavier que le 6500/1 envoie à l'Amiga. La première
résume ces codes par ordre numérique pour vous permettre de savoir à quelle touche correspond
quel code ; la seconde, sous forme graphique, vous permettra de repérer rapidement le code d'une touche
particulière.
Codes de $00 à $3F
Ces codes sont ceux assignés aux touches alphanumériques et de ponctuation. Les lettres représentées
sur les touches sont bien entendu différentes de pays en pays, mais les codes clavier restent
les mêmes. Les touches $2B et $30 sont des exceptions ; elles n'existent pas sur le clavier original
américain et ont été ajoutées pour balancer le nombre plus élevé de caractères sur les claviers européens.
Codes de $40 à $5F
Ces touches sont communes à tous les types de claviers.
- 40 : Espace.
- 41 : BackSpace (retour arrière).
- 42 : Tab (tabulation).
- 43 : Enter (entrée du pavé numérique).
- 44 : Return (retour du pavé principal).
- 45 : Esc (échappement).
- 46 : Del (suppression).
- 4C : Curseur haut.
- 4D : Curseur bas.
- 4E : Curseur droit.
- 4F : Curseur gauche.
- 50-59 : Touches de fonctions F1 à F10.
- 5F : Help (aide).
Codes de $60 à $67
- 60 : Shift de gauche.
- 61 : Shift de droite.
- 62 : Caps-Lock (verrouillage majuscule).
- 63 : Control.
- 64 : Alt de gauche.
- 65 : Alt de droite.
- 66 : Amiga de gauche (ou Commodore).
- 67 : Amiga de droite (ou Commodore).
|
