Section courante

A propos

Section administrative du site

Sommaire



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


Dernière mise à jour : Dimanche, le 1 mai 2016