Les Chevaliers de Malte/Développeur - Assembleur et Pascal - Clavier

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 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: Jeudi, le 26 janvier 2006