Discussion :

[Automato]

Bonjour tout le monde,

Je suis nouveau parmi vous et c'est mon premier message dans ce site.
J'ai des connaissances de base dans le langage de programmation C, et j'ai besoin de votre aide.
J'utilise le logiciel Microsoft visual studio pour mes programmes en C sous Windows et j'aimerais savoir comment peut-on détecter un événement du clavier (exemple appui sur le bouton "ALT") pour effectuer un comportement (exemple écrire un message d'information).

J'utilise un programme simple exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
main ()
{
int i = 1 ;
while(i)
 printf("pas d appui");
 
????????
 
return 0;
}

Mon but est d'ajouter la partie de code manquante qui permet de détecter à n'importe quel moment s'il y a un appui sur la touche du clavier "ALT" et une fois qu'il y a un appui sur ce bouton là, le programme écrit "touche detectee" et change la valeur de i ( exemple : printf("touche detectee"); et i = 0.

Merci d'avance.

[Crackerz]

Bonjour,

Il me semble qu'il te faut utiliser une bibliothèque pour pouvoir "capter" les touches qui ne font pas partie de la table ASCII. Quoi qu'il en soit l'idée est là, imaginons que la touche que tu veux ne soit pas "alt" mais "a" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
 
int main(void){
 
    char c;
    int i = 1;
    while(i){
 
        if((c=getchar()) == 'a'){
            printf("Touche \"a\" saisie, i = %d\n",i);
            i++;
        }
    }
 
    return 0;
}

[Médinoc]

Il faut aussi une bibliothèque (supportée par l'OS) pour pouvoir détecter de manière non-bloquante si une touche a été pressée ou non: Le C standard n'offre pas cette possibilité.

[Automato]

Merci BooMan pour ta réponse, je vais essayer l'instruction

Médinoc
Qu'est ce que ça veut dire : détecter de manière non-bloquante si une touche a été pressée ou non ? et est ce que t'as des exemples concrets ?
Merci.

[Obsidian]

Bonjour et bienvenue,

Qu'est ce que ça veut dire : détecter de manière non-bloquante si une touche a été pressée ou non ? et est ce que t'as des exemples concrets ?

Cela veut dire que, d'une part, le langage C en lui-même est indépendant de la machine et du système d'exploitation sur lesquels on exécute ses programmes. La bibliothèque standard définie par la norme C prévoit la disponibilité d'une « entrée standard », qui s'exploite comme un fichier. Par défaut, cette entrée standard est reliée au clavier de la console de l'utilisateur, mais elle peut être renvoyée vers le contenu d'un fichier ou la sortie d'un autre processus. C'est cette entrée que tu lis lorsque tu fais getchar() (entre autres).

Ça signifie également qu'il faut qu'un caractère soit arrivé jusqu'à ton processus. Tant que ce n'est pas le cas (et comme les différents périphériques ont tous un temps d'accès qui leur est propre), la fonction en question va attendre qu'il arrive et, donc, tu ne pourras rien faire d'autre en attendant. En outre, certains systèmes d'exploitation utilisent une console qui utilise une discipline de ligne, qui permet de conserver tous les caractères saisis du côté utilisateur dans un buffer et ne les envoyer au processus qu'à l'appui sur Entrée, ce qui permet à cet utilisateur de corriger éventuellement sa saisie avant de la soumettre. Certaines machines à écrire électroniques des années 1980 étaient d'ailleurs équipées d'un écran LCD rudimentaire pour faire la même chose. Dans ce cas, tu risques d'avoir des surprises côté programme car tu n'obtiendras aucun caractère tant que tu n'auras pas appuyé sur Entrée et, alors, tous ceux que tu aura saisi jusque là vont arriver d'un seul bloc à ton programme.

D'autre part, « Alt » est, à ma connaissance, une touche spécifique à l'IBM PC (et à ses clones, que l'on utilise aujourd'hui) et est surtout un modificateur, comme Shift. C'est donc une touche qui te permet de saisir un caractère alternatif situé sur la même touche qu'un caractère principal, par exemple le « # ». Donc, aucun caractère n'est émis quand tu appuies seulement sur Alt et ton programme ne recevra rien. Avec des terminaux distants branchés sur des lignes séries, il est impossible de savoir à l'avance si un utilisateur a appuyé ou non sur cette touche. En travaillant en local sur un ordinateur donné, il est possible d'obtenir cette information mais à condition de surveiller directement l'activité du périphérique qui gère le clavier. En réalité, comme c'est un acte relativement commun, cela va être transmis parmi les événements de l'environnement graphique, mais cela veut dire qu'il faudra travailler à un autre niveau et faire de la programmation système. Et bien sûr, ce ne sera pas portable a priori. Il faudra écrire une routine propre à chaque environnement.

[Automato]

Bonjour,
Merci pour vos réponses.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
while(i){
 
        if((c=getchar()) == 'a'){
            printf("Touche \"a\" saisie, i = %d\n",i);
            i++;
        }
}

Après avoir essayé le code au dessus, une fois le programme arrive à la ligne if((c=getchar()) == 'a'), il arrête l'affichage et me demande de saisir un caractère (il m'oblige de saisir un caractère avant de continuer).
Mon but c'est que le programme continue l'affichage en temps réel et sans cesse et une fois il détecte un appui (sans le demander à l'utilisateur), il fais une action (affichage d'un message, incrémenter un compteur,...).

[jouana]

Bonjour,

enfaite je retire mon post pas vu que c'était sous windows :s

Regarde la winapi la doc est pas trop mal foutu sinon comme dit plus haut cherche des lib qui pourrais te simplifier la vie

Voila je te laisse un peu chercher, bon courage

j'ai trouvé ça si ça peux t'aider http://www.developpez.net/forums/d10...aison-touches/

[Automato]

Bonjour Jouana,

Merci pour ton message, cependant, le fait de me donner des liens et des librairies et me demander d'aller chercher tout seul n'est pas un encadrement ça n'aides pas à avancer . Aller chercher dans d'autres pages pour une simple instruction n'est pas bon, il suffit juste de me montrer cette instruction mais bon merci en tout cas (de toute façon j'ai jeté un coup d’œil sur les liens et j'ai trouver des choses compliqués pour une question très simple)
Moi j'ai poster ma question ici par ce que je sais qu'il y a des experts qui peuvent me donner l'instruction dans deux trois lignes par ce que je ne voulais pas utiliser de l'orienté objet avec C++ j'ai voulu seulement utiliser un programme simple en C.

Mais bon après une longue recherche sur le net j'ai pu trouver l'instruction qui me permet de détecter la touche du clavier appuyée par l'utilisateur sans faire une pause du programme parce que getchar() toute seule fait une pause du programme et demande à l'utilisateur de rentrer un caractère.
La fonction qui permet de faire ça est kbhit()

exemple d'utilisation simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
#include <conie.h>
.
.
If(kbhit())
{
   detection=getch() ;
}
If (detection == ‘T’)
{
    Printf(«touche frappée » ) ;
    compteur++
}

Voila, mon problème est résolu
Merci pour tout le monde

[Obsidian]

Mais bon après une longue recherche sur le net j'ai pu trouver l'instruction qui me permet de détecter la touche du clavier appuyée par l'utilisateur sans faire une pause du programme parce que getchar() toute seule fait une pause du programme et demande à l'utilisateur de rentrer un caractère.
La fonction qui permet de faire ça est kbhit()

exemple d'utilisation simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
#include <conie.h>
.
.
If(kbhit())
{
   detection=getch() ;
}
If (detection == ‘T’)
{
    Printf(«touche frappée » ) ;
    compteur++
}

Voila, mon problème est résolu
Merci pour tout le monde

Malheureusement, c'est loin d'être aussi simple : kbhit(), et conio.h d'une manière générale, ne sont absolument pas portables. C'est pratique pour commencer mais s'appuyer dessus trop longtemps risque de te donner de mauvaises habitudes.

Ce que l'on essayait de te dire, c'est que la norme C proprement dite ne définit rien de particulier à ce sujet et, en fait, à aucun endroit dans ses 540 pages cette norme n'utilise même le mot « clavier » (keyboard). Et cela parce qu'un micro-processeur ne travaille pas forcément dans un environnement qui en est pourvu. C'est surprenant avec un ordinateur personnel, mais ça commence à le devenir beaucoup moins quand on travaille sur tablette tactile.

Ça veut dire que, d'une part, il va falloir vérifier que le clavier peut effectivement être lu (ça, c'est acquis) et, d'autre part, te tourner vers les facilités proposées par ton système d'exploitation, ou par une norme plus générale reconnue par le système en question.

Si tu utilises kbhit(), c'est que tu travailles sous Windows, mais c'est loin d'être le cas de tout le monde. En particulier, beaucoup de gens ici travaillent sous Unix ou Linux. La norme POSIX qui en est issue propose quelque chose de plus général : elle permet de modifier le descripteur d'un fichier ouvert pour rendre non bloquants tous les appels qui le sont par défaut. Ça s'applique à l'entrée standard comme au reste et te permet donc d'arriver à tes fins sans même recourir à kbhit(). Malgré ça, il se peut encore que l'équipement qui t'envoie ces caractères (comprendre : le terminal) ait choisi de les bufferiser avant de te les soumettre. Dans ce cas, il faudra préalablement lui demander également de ne pas le faire.

[Invité]

Ou sinon tu fait appel à ma fonction asm, après pour les gens qui diront que l'asm n'est pas portable, je souligne que je n'utilise pas d'interruptions logiciel d'un quelconque OS .
Ensuite pour ce qui est de l'utilisation de ce port, j'ai la net impression que le composant nommé est universel pour tout les PC avec support clavier.
Et pour les pro-GAS, no comment

(Attention texte exploitable que dans notepad++ sous risque de confusion dans la lecture)

Code ASM :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
	;=============
	 ; keywait
	 ; Attend qu'une touche du clavier soit préssée via le controlleur 8042 et stocke la valaur reprensentative de la touche préssée.
	 ; dans 'al'.
	 ; Entrée : touche_clavier 
	 ; Sotie: al
	;=============	
	keywait:
		; <a href="http://www.computer-engineering.org/ps2keyboard/" target="_blank">http://www.computer-engineering.org/ps2keyboard/</a>
		; Le composant 8042 est accesible via les port 0x64 et 0x60, le port 0x64 sert à envoyé des commandes vers le controlleur 8042.
		; Et le port 0x60 sert à envoyer les parametres que la commande attend. Bien sur ces ports sont piloter en sortie (out).
 
		mov		al, 0xD2	; (Write keyboard buffer) - Parameter written to input buffer as if received from keyboard.
							;							Les parametres sont écris sur le buffer d'entrée comme s'il le recevait 
							;							depuis le clavier.
							; Ici on envoie sur l'input buffer (port 60h) un MC (Make code)
		out		0x64, al
		; BreakCodes= KeyUp	
		; MakeCodes= KeyDown
		; Scancode: |7|6|5|4|3|2|1|0|
		;			 | |_|_|_|_|_|_|_.-->{Scancode}
		;			 |
		;			 |_.--> '1'= BreakCodes '0'= MakeCodes
 
		mov		al, 0x80	; al=10000000b
		out		60h, al
		keyup:
			in		al, 0x60
			and	 	al, 10000000b
		jnz		keyup	; Si le 8eme bit == 1 Alors sauter à keyup
		Keydown:
		in		al, 0x60
	ret	
	;=============
	; /keywait	      
	;=============

[-Eks-]

Salut,

Comme notre ami (Automato) utilise Microsoft visual studio et qu'il recherche une solution simple lui permettant de détecter une touche pressée au clavier, il est compréhensible qu'il considère que kbhit répond à ses attentes, puisque "cela marche pour lui".

Cependant, comme cette fonction n'est accessible que par conio.h et est un héritage du monde DOS de Microsoft (et que son usage n'est pas supporté par Windows lui-même sur tous ses systèmes), tant qu'à faire du non standard, peut-être qu'il devrait utiliser l'API Win32 pour arriver à ses fins (qui au moins est commune pour les compilateurs Windows, d'origine Microsoft ou pas).

jouana lui a pertinemment proposé un lien vers une ressource lui indiquant comment faire un "hook" du clavier, ce qui est la solution la plus économe en ressources, mais assez compliquée à mettre en oeuvre.

Autrement l'API Win32 propose aussi GetAsyncKeyState, qui permet de faire du polling comme kbhit et de rapidement consulter l'état du clavier, et qui n'impose pas la gestion des messages Windows.

Cela donne un code simple comme comme cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
#include <windows.h>
 
int main(void)
{
    printf("Press Alt to end this program\n");
    /* infinite loop */
    while (1) {
        /* test most significant bit of the
         * value returned by GetAsyncKeyState */
        if (GetAsyncKeyState(VK_MENU) & 0x8000) {
            printf("Alt pressed, thank you.\n");
            break;
        }
    }
    return 0;
}

Ce code compile sous Windows même avec Codeblocks et gcc (MinGW), et il ne se repose que sur l'API Windows au lieu de l'implémentation des fonctions de conio.h par Microsoft visual studio.

VK_MENU est un "virtual key code" qui permet de se référer à Alt ou Alt Gr (autrement il y a VK_LMENU pour Alt et VK_RMENU pour Alt Gr). La liste des "virtual key code" définis par l'API Microsoft est accessible là : http://msdn.microsoft.com/en-us/libr...=vs.85%29.aspx.

Avec la même fonction GetAsyncKeyState et le bon "virtual key code", tu peux lire l'état des boutons de la souris aussi :-)


Eks

[Invité]

Tu parle de moi ?

Dois-je te rappelé que mon code asm est portable sur tout les OS tournant avec un pc à processeur intel ?

Ou sinon tu fait appel à ma fonction asm, après pour les gens qui diront que l'asm n'est pas portable, je souligne que je n'utilise pas d'interruptions logiciel d'un quelconque OS .
Ensuite pour ce qui est de l'utilisation de ce port, j'ai la net impression que le composant nommé est universel pour tout les PC avec support clavier.

Fait l’expérience sur ton pc et on verras

Ah oui j'oubliais c'est de l'asm from nasm

Code BATCH :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
@echo off
cd..
 
nasm -f win32 1.ASM/traveaux.asm -o 4.EXE/traveaux.exe
 
echo DONE
pause

Enjoyt it

Et tu verras clairement que le programme traveaux.exe se met en pause et attend une touche, qui, une fois fait, est détruit de la RAM.


PS: traveaux.asm contient le code citée dans le topic

[-Eks-]

Tu parle de moi ?
(...)

non, quand j'ai dit "notre ami", je parlais d'Automato, le posteur initial, qui indique dans son message d'origine qu'il utilise Microsoft visual studio.

j'ai désormais ajouté cette précision à mon message.

[Invité]

haha désolé


(épic ce quiproquo, je laisse les messages précédent , même si ça était inutile )

[Obsidian]

Tu parle de moi ?

Dois-je te rappelé que mon code asm est portable sur tout les OS tournant avec un pc à processeur intel ?

Ce n'est malheureusement pas vrai.

• D'abord, il est hors sujet : le primo-postant cherche à être informé de l'appui sur une touche de manière non bloquante, d'où l'utilisation de kbhit(). Ton programme, lui, contient un spinlock qui met le programme en attente jusqu'à son arrivée ;
• Ce n'est pas du C. Ton message aurait plus sa place dans le forum assembleur. Il y a des manières conventionnelles de gérer les différents cas de figure et il appartient à tout étudiant d'essayer de faire les choses proprement, quitte a adopter l'approche qui l'intéresse une fois qu'il maîtrise ces sujets ;
• Si ton programme « tourne sur tout PC avec processeur Intel », c'est que par définition il n'est pas portable. Le principe même du C est d'être un langage épousant au plus proche le fonctionnement réel du micro-processeur mais en s'affranchissant de toute spécificité propre à une plate-forme donnée ;
• Ton programme est un code assembleur 16 bits qui fait accès directement aux ports d'entrée-sorties. Ça ne fonctionne que parce que le mode réel est émulé par l'environnement de la ligne de commande quand tu travailles en mode console, sous Windows. Essaie de coller la même chose dans un exécutable Linux ou surtout un programme Windows natif fenêtré en 32 ou 64 bits, pour voir ;
• De la même façon, ça ne marchera pas directement non plus avec les claviers USB. Uniquement si ton BIOS est fait pour prendre cela en charge et émule le fonctionnement de l'antique 8042 en reconstituant de toute pièce un événement clavier quand on l'utilise ;
• Ton programme court-circuite les différentes strates de ton système d'exploitation et entre en conflit avec lui. À si bas niveau, il risque de ne plus être capable d'intercepter ni les raccourcis clavier, ni même les touches système qui te permettraient de te sortir d'affaire en cas de plantage (telles que Ctrl+Alt+Del) ;
• Ton programme ne tient pas compte du buffer clavier. Toutes les touches frappées avant l'entrée dans ta routine sont purement ignorées. Pour autant, elles restent quand même dans le buffer en question et risquent d'être traitées APRÈS la frappe des dernières touches ;
• Ça ne fonctionnera pas en environnement multitâches. C'est génant. Même si ton programme ne contient qu'un seul fil, tu fais toujours fonctionner plusieurs processus en parallèle sur une même machine ;
• Ça ne fonctionnera définitivement plus si le clavier se trouve sur une machine distante, typiquement à travers une connexion ssh ;
• Ça ne fonctionnera pas non plus si l'entrée standard de ton programme est chaînée, par un pipe « | » avec la sortie d'un autre ;

L'assembleur, c'est génial, et il y a même ici un sous-forum « programmation d'OS » dans la rubrique consacrée pour ceux qui veulent savoir comment leur machine fonctionne et tout reprendre depuis le point de départ. Mais cet exemple-ci est vraiment la dernière chose à faire faire à une personne qui débute totalement en C.

[Médinoc]

Hahaha, ça c'est du cassage.

Plus sérieusement, des précisions sur le message de -Eks-: GetAsyncKeyState() bypasse complètement les histoires de buffer clavier et compagnie, et à la place pose simplement à Windows une question simple: Est-ce que la touche voulue est enfoncée, là, maintenant, tout de suite?

À l'inverse, l'implémentation Microsoft de _kbhit() se base sur le "console input buffer"; elle utilise PeekConsoleInput() pour voir si ledit buffer (associé à la console de ton programme) contient au moins un événement "appui sur une touche".

[SamGanjiPirate]

ATTENTION DETERREMENT !!! 2014 - 2020 : Je vous laisse réfléchir

Prévoir deux fichiers :

- Le fichier principal où tu auras rajouté le code suivant à un endroit stratégique (à toi de voir) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
    //	Interrompre le programme dès que la touche 'a' est pressée.
 
        FILE * Test_a = fopen("Test_touche.txt", "r");
 
        if(Test_a == NULL)
            exit(1);
 
        if(fgetc(Test_a) == 'a')
        {
            fclose(Test_a);
            break;
        }

- Un fichier secondaire avec le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
 
int main(int argc, char *argv)	//  OU PLUS SIMPLEMENT	int main(void)          en l'absence de SDL, par exemple.
{
char detection;
 
    while(1)
    {
        if(kbhit())
        {
            detection=getch();
        }
        if (detection == 'a')
        {			
            FILE * Is_typed_a = fopen("Test_touche.txt", "w");
 
            if(Is_typed_a == NULL)
                exit(1);
 
            fprintf(Is_typed_a, "a");
 
            fclose(Is_typed_a);	
            printf("touche a frappee \n" );
            break;
        }
    }
}

A partir de là, tu ouvres DEUX consoles (Exécuter -> cmd -> ENTREE DEUX fois )

- Dans l'une, tu lances le fichier principal.
- Dans l'autre, tu lances le fichier secondaire et le tour est joué.

Remarque : Euh, ça fonctionne sous Windows, toujours