Sommaire
- Introduction
- État clavier par le DOS
- État clavier par le BIOS
- État clavier par les accès mémoires
- État clavier par les accès directe par port
Introduction
Lorsqu'on écrit un programme, la première chose qu'on veut savoir (lorsqu'on ne veut pas qu'il attends bêtement après une touche clavier), c'est s'il y a des entrées de codes clavier dans le tampon réservés à cette effet. Pour ce faire, il existe tellement de méthode que je ne saurais tous les énumérer. Cependant en voici les principales et leur programmation en assembleur.
État clavier par le DOS
Dans l'exemple suivant, si le clavier contient au moins un caractère dans le tampon clavier, la valeur 1 est retournée sinon elle retournera 0 dans le registre AL. Pour ce faire, la fonction 0Bh de l'interruption 21h du DOS est employée.
MOV AH,0Bh
INT 21h
AND AL,1
État clavier par le BIOS
Dans l'exemple suivant, si le clavier contient au moins un caractère dans le tampon clavier la valeur 1 est retournée sinon est retournera 0 dans le registre AL. Pour ce faire, la fonction 01h de l'interruption 16h inclus dans n'importe quel BIOS en ROM est employée.
MOV AX,1
INT 016h
MOV AL,0
JZ @End
MOV
AL,1
@End:
État clavier par les accès mémoires
Prenez note que les routines suivantes sont écrites en fonction d'un algorithme de programmation de langage Turbo Pascal ayant le format suivant:
Function Keypressed:Boolean;Begin
Inline($FA);
(* CLI *)
Keypressed:=MemW[$0040:$1A]<>MemW[$0040:$1C];
Inline($FB); (*
STI *)
End;
Cette fonction retourne la valeur True si le tampon clavier à au moins une touche en réserve et dans le cas contraire False (c'est à dire dans le cas où il n'y a aucun caractère en mémoire tampon clavier). Naturellement cet exemple ne s'applique quand mode réel et en DPMI il faudra remplacer $0040 par Seg0040.
Dans l'exemple suivant, la lecture se fait par l'entremise de la zone mémoire RAM utilisée par le BIOS, c'est à dire le segment 0040h et afin de ne pas avoir de conflit avec les routines du BIOS, nous prenons soins d'interdire les requêtes interruptions extérieures (IRQ). La comparaison des adresses de tampons de départ (0040h:001Ah) puis de fin (0040h:001Ch) sont ensuite vérifier et s'ils sont égal c'est que le tampon clavier est forcément vide. L'exemple suivant s'applique quand mode réel:
XOR AX,AX
MOV ES,AX
CLI
LES
DX,ES:[41Ah]
STI
MOV
BX,ES
CMP BX,DX
JE @End
MOV
AL,1
@End:
L'exemple suivant s'applique en mode DPMI, prenez note que la variable Seg0040 doit absolument contenir l'adresse du segment de RAM BIOS.
XOR AX,AX
MOV ES,Seg0040
MOV DX,ES:[1Ah]
MOV BX,ES:[1Ch]
CMP BX,DX
JE @End
MOV
AL,1
@End:
État clavier par les accès directe par port
Il y aurait naturellement la technique de comparaison avec le port 61h avec un Et Binaire 80h, mais cette technique ne compatibilité à 100%! Toutefois l'exemple suivant permettra d'imaginer de quel façon on peut lire une touche en utilisant le IRQ1. La procédure NewInt09 est le coeur du problème, elle extraira les valeurs et les stockera dans le tampon Key. On n'effectuera pas de traitement directe pour obtenir une touche de combinaison dans cet exemple, car on doit d'abord comprendre que toutes les touches peuvent être combiner en théorie, et qu'il s'agit uniquement d'une convention, le Ctrl+F1, Alt+F,... Si vous avez un coter marginal, vous pourriez décider que votre programme demande d'enfoncer la lettre C en meme temps que le U, il y aurait aucun obstacle matériel pour atteindre votre but... Vous remarquerez que la variable AnyPressed est enfoncé chaque fois qu'au moins une touche est enfoncé. Et que les 128 clés claviers sont stocké de façon autonome dans un tampon. Par exemple, pour vérifier si la touche ESC est enfoncé, on fera un KEY[1]=True
Var
Key:Array[0..127]of
Boolean;
AnyPressed:Boolean;
Procedure NewInt09;Interrupt;Assembler;ASM
STI
XOR CH,CH
MOV DX,060h
IN AL,DX
MOV CL,AL
AND CL,07Fh
MOV BX,Offset Key
ADD BX,CX
MOV SI,BX
{$IFOPT G+}
SHR AL,7
{$ELSE}
ROL AL,1
AND AL,1
{$ENDIF}
XOR AL,1
MOV [SI],AL
MOV
AnyPressed,AL
MOV DX,061h
IN AL,DX
MOV CL,AL
OR AL,080h
OUT DX,AL
MOV AL,CL
OUT DX,AL
MOV AX,020h
MOV DX,AX
OUT DX,AX
CLI
END;
On initialisera et on restaura donc cette interruption de la façon suivante:
Var
OldInt09:Pointer;
{ Cette
procédure initialise notre interruption 09h }
Procedure
InitInt09;Begin
GetIntVec($09,OldInt09);
SetIntVec($09,@NewInt09);
FillChar(Key,SizeOf(Key),0);
End;
{ Cette procédure remet l'ancienne interruption 09h }
Procedure
RestoreInt09;Begin
SetIntVec($09,OldInt09);
End;
Et on exploitera cette interruption de la façon suivante:
Const
rqkEsc=1;
{ Escape}
rqkCtrl=$1D;
{ Ctrl}
rqkAlt=$38;
{ Alt}
rqkSpaceBar=$39;{
Barre d'espacement }
BEGIN
InitInt09;
WriteLn('Presse
ESC pour quitter...');
Repeat
If
Key[rqkCtrl]and
Key[rqkAlt]and
Key[rqkSpaceBar]Then
WriteLn('Ctrl+Alt+Barre
d''espacement enfoncé');
Until
Key[rqkEsc];
RestoreInt09;
END.
Cliquez ici pour télécharger l'exemple source:
| Nom | Description |
|---|---|
| RAWKEY.ZIP | Fichier compressé contenant le source RAWKEY.PAS ainsi que l'exécutable montrer en exemple. |