Newsgroup: it.comp.lang.c
Titolo: Codice Tasti

Se io volessi il codice dei tasti della tastiera SU GIU DESTRA SINISTRA ,
per poterli riconoscere in una stringa o in un carattere, come dovrei fare?
non fanno parte dell'ASCII ?
ciao e grazie.
Fly

 non fanno parte dell'ASCII ?
No, quei tipi di codici (scan codes) dipendono in parte dall'hardware ed in
parte dall'OS su cui lavori, il sistema migliore e' consultare la
documentazione dell'OS per sapere come vengono interpretati e/o gestiti.
Davide

 ha scritto nel messaggio
news:mo3Q8.37837$Kt3.9...@twister2.libero.it...



Allora: soluzione per PC: fai una getch(); se ti ritorna 0, vuol dire che č
stato premuto qualcosa che non ha un codice ASCII; in tal caso richiami
getch() e testi il ritorno con dei valori che corrispondono alle frecce.
Quali? Prova! Ovvero:
printf("Premi freccia sinistra");
getch(); //controlla che sia 0
printf("%d",getch());
e annoti il valore che stampa, che corrisponde sempre alla freccia sinistra.
Almeno su Dos/Windows, ma non penso che altrove cambi. Almeno prova, sempre
meglio di studiarsi questa "ncurses", mi sembra assai piů semplice.
Ciao!

 printf("%d",getch());
Ma la getch() mi pare che funga solo sotto linux....in che libreria si
trova?
Fly

 trova?
No, sotto linux/unix a quanto so non esiste nemmeno. Puoi trovarla
esclusivamente nei sistemi Windows
includendo la libreria CONIO.H.
(Credo che siamo quasi OT in questo NG)
Joshi



La soluzione che proponi č sbagliata. Se premo uno di quei tasti lui
continua ad attendere finchč non premo return....e quindi mi da il valore
del return( 10).



getch si trova sotto conio.h in dos/win, e nelle ncurses (curses.h ,
ncurses.h) sotto linux/
unix.in
 quest'ultimo esiste anche termcap, se non
erro, che permette cose simili.
nota: le ncurses sono portate su molti sistemi operativi, quindi se devi
ti consiglio di imparare ad utilizzare queste.
Ciao,
Riccardo

 ha scritto nel messaggio
news:STpQ8.43965$j65.1...@twister1.libero.it...


 del return( 10).
Questa è nuova, hai provato? getch quando mai ha aspettato return?? la prima
getch prende 0, la seconda il codice; semmai se NON premo uno di quei tasti,
cioè se la prima getch non dà 0, devi evitare la seconda, altrimenti aspetta
2 tasti. Sono arcisicuro di quanto ho scritto. Se hai controllato, controllo
anch'io. Purché tu sia su DOS/Windows, altrimenti non lo so, ma getch, se
esiste, NON aspetta invio, serve apposta. Inoltre non ti darebbe return
comunque, perché getch prende il primo carattere premuto che c'è nel buffer,
non l'ultimo!
Ciao e sta' più attento.
--
Paolo Giarrusso
Per rispondere togliere solo "TOGLIMI" dall'indirizzo, non _spam.

 wrote in message
news:afvja1$8k1$
3...@lacerta.tiscalinet.it

Il metodo proposto e' alquanto scadente non permette la pressione di
piu' tasti contemporaneamente.
Io ti consiglio di provare questa libreria che ho scritto. Sostituisce
l'handler della tastiera. I tasti premuti li puoi vedere
tremite una semplice consultazione dfel vettore _Keyboard ad esempio con
if (_Keyboard[KEY_ALT] == 1 &&  _Keyboard[KEY_F1] == 1) {
   //do
}
In questo modo hai il completo controllo della tastiera. Attento che
pero' ora ogni tasto premuto deve essere controllato da te.
Ad esempio non funziona piu' la combinazione CTRL+ALT+CANC.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *\
Codici dei tasti tastiera italiana.
*
* In questo header file sono riportati i codici, in base 10, dei tasti
della
* tastiera italiana. Alcuni codici di tasti sono uguali, ad esempio
l'enter
* del tastierino numerico ha lo stesso codice dell'altro enter, cosi' i
due
* CTRL, non i due SHIFT pero'.
* I tasti sono tutti identificati con KEY_nometasto, unica eccezione
quelli
* relativi al tastierino numerico che sono identificati con
KEY_TN_nometasto.
*
*Alberto T.
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* */
 #ifndef __KEYBIT_H
 #define __KEYBIT_H
 // Caratteri alfabetici.
 #define KEY_A	30
 #define KEY_B  48
 #define KEY_C  46
 #define KEY_D  32
 #define KEY_E  18
 #define KEY_F  33
 #define KEY_G  34
 #define KEY_H  35
 #define KEY_I  23
 #define KEY_J  36
 #define KEY_K  37
 #define KEY_L  38
 #define KEY_M  50
 #define KEY_N  49
 #define KEY_O  24
 #define KEY_P  25
 #define KEY_Q  16
 #define KEY_R  19
 #define KEY_S  31
 #define KEY_T  20
 #define KEY_U  22
 #define KEY_V  47
 #define KEY_W  17
 #define KEY_X  45
 #define KEY_Y  21
 #define KEY_Z  44
 // Caratteri non alfabetici
 #define KEY_VIRGULE			51  //,
 #define KEY_DOT				52  //.
 #define KEY_UNDERSCORE			53  //_
 #define KEY_AT					39  //@
 #define KEY_OPEN_BRACKET       26  //[
 #define KEY_CLOSE_BRACKET      27  //]
 #define KEY_u  				43  //ù
 #define KEY_a					40  //à
 // Numeri
 #define KEY_1	2
 #define KEY_2	3
 #define KEY_3	4
 #define KEY_4	5
 #define KEY_5	6
 #define KEY_6	7
 #define KEY_7	8
 #define KEY_8	9
 #define KEY_9 	0
 #define KEY_0	11
 // Tasti funzione
 #define  KEY_F1	59
 #define  KEY_F2	60
 #define  KEY_F3	61
 #define  KEY_F4	62
 #define  KEY_F5	63
 #define  KEY_F6	64
 #define  KEY_F7	65
 #define  KEY_F8	66
 #define  KEY_F9	67
 #define  KEY_F10	68
 #define  KEY_F11	87
 #define  KEY_F12	88
 // Tasti scorrimento ed inserimento
 #define  KEY_BLOC_SCORR	70
 #define  KEY_INS			82
 #define  KEY_CANC          83
 #define  KEY_FINE          79
 #define  KEY_HOME			71
 #define  KEY_INS			82
 #define  KEY_PAGE_UP		73
 #define  KEY_PAGE_DOWN		81
 // Tasti speciali
 #define KEY_ESC			1
 #define KEY_SLASH			41
 #define KEY_TAB			15
 #define KEY_CAPS_LOCK		58
 #define KEY_DELETE			14
 #define KEY_ENTER          28
 #define KEY_LEFT_CTRL		29
 #define KEY_RIGHT_CTRL 	29
 #define KEY_LEFT_SHIFT     42
 #define KEY_RIGHT_SHIFT	54
 #define KEY_SPACE			57
 #define KEY_LEFT_ALT		56
 #define KEY_RIGHT_ALT		56
 #define KEY_MENU			93
 // Tasti freccia
 #define KEY_UP		72
 #define KEY_DOWN	80
 #define KEY_LEFT	75
 #define KEY_RIGHT	77
 // Tastierino numerico
 #define KEY_TN_BLOCK_NUM	63
 #define KEY_TN_BACK_SLASH	53
 #define KEY_TN_STAR		55
 #define KEY_TN_MINUS		74
 #define KEY_TN_PLUS		78
 #define KEY_TN_1			79
 #define KEY_TN_2			80
 #define KEY_TN_3			81
 #define KEY_TN_4			75
 #define KEY_TN_5			76
 #define KEY_TN_6			77
 #define KEY_TN_7			71
 #define KEY_TN_8			72
 #define KEY_TN_9			73
 #define KEY_TN_0			82
 #define KEY_TN_ENTER		28
 #define KEY_TN_DOT			83
 #endif
 //****************************
---cut here
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *\
 Keyboard Library ver 1.0
 Gestione della tastiera tramite riprogrammazione dell'interrupt 09h.
 Alberto
 \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* */
 #ifndef __KEYBOARD_H
 #define __KEYBOARD_H
 #include "keycode.h"	
 #include "type.h"			
 #include <dos.h>
 #ifndef MAX_KEY
 #	define MAX_KEY  128
 #endif
 #define KEYB_PORT 0x60
 #define KEYB_INT  0x09
 typedef unsigned char UBYTE;
 extern UBYTE _Keyboard[MAX_KEY];
 extern void interrupt (*Bios_Handler) (...);
 void interrupt Keyb_Handler (...);
 class ATS_Keyb {
	public:
		ATS_Keyb	(bool Set);
	    ~ATS_Keyb	(void);
	private:
		int  m_Active;
	public:
		void	Set_Handler		(void);
		void	Restore_Handler (void);
		void	IsActive		(void);
 };
 #endif
---cut here
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *\
 Implementazione delle funzioni per lagestione della tastiera
 Alberto 
 \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* */
 #include "keyb9h.h"
 #include "type.h"
 // Vettore in cui viene scritto lo stato di ogni singolo tasto:
 // Premuto = 1, Rilasciato = 0;
 UBYTE _Keyboard[MAX_KEY];
 // Definizione dell'interrupt. Nella prima parentesi si memo. il ptr.
 // all'handler che si andra' a sostituire, nella seconda i parametri
del
 // nuovo handler.
 void interrupt (*Bios_Handler) (...);
 // Purpose:	Sostituisce l'interrupt 09H, relativo alla tastiera.
 // Returns:	Nulla.
 // Params:     Nessuno.
 // Note:
 void interrupt Keyb_Handler (...) {
	asm  	in   al, KEYB_PORT  // Leggo il tasto premuto.
	asm  	mov  si, ax			// Copio il valore del tasto in si
	asm  	and  si, 0x7F		// Azzero il primo bit, per usare si come indice
								// tra 0 e 127.
	asm  	test al, 0x80		// Se il primo bit e' 1 il tasto e' premuto.
	asm     jz   pressed		// ovvero il test da 0 quindi setto 1
	asm     mov  byte ptr _Keyboard[si], 0 // altrimenti setto 0
	asm     jmp  pic			// do via libera al PIC
	pressed:
	asm     mov  byte ptr _Keyboard[si], 1
	pic:
	asm     mov  al, 0x20
	asm     out  0x20, al
 }
 // Purpose:	Costruttore della classe.
 // Returns:	Nulla.
 // Params:		Valore che indica se settare o meno direttamente l'handler.
 // Note:		L'handler viene settato se Set assume valore true.
 ATS_Keyb::ATS_Keyb (bool Set) {
	m_Active = 0;
	if (Set == TRUE)
		Set_Handler ();
 }
 // Purpose:	Distruttore della classe.
 // Returns:	Nulla.
 // Params:		Nessuno.
 // Note:		In caso l'handler sia ancora attivo, ripristina l'handler
 //				del bios.
 ATS_Keyb::~ATS_Keyb (void) {
	if (m_Active)
		Restore_Handler ();
 }
 // Purpose:	Imposta un nuovo handler di gestione della tastiera.
 // Returns:	Nulla.
 // Params:		Nessuno.
 // Note:       L'handler che sostituisce e' la funzione Keyb_Handler.
 //             Prima per• rileva il ptr. dell'handler che sostituira'.
 void ATS_Keyb::Set_Handler (void) {
	Bios_Handler = _dos_getvect (KEYB_INT);
	_dos_setvect (KEYB_INT, Keyb_Handler);
	for (int i = 0; i < MAX_KEY; ++i)
		_Keyboard[i] = 0;		
 }
 // Purpose:	Ripristina l'handler della tastiera.
 // Returns:	Nulla.
 // Params:		Nessuno.
 // Note:       Viene chiamato dal distruttore se ancora attivo alla sua
 //				chiamata.
 void ATS_Keyb::Restore_Handler (void) {
	_dos_setvect (KEYB_INT, Bios_Handler);
}
//PICCOLO ESEMPIO
#define TRUE 1
int main () {
ATS_Keyb keyb (TRUE);
while (_Keyboard[KEY_ESC] == 0) {
  printf ("\nPremi un ESC per terminareeeeee...");
}
keyb.Restore_Handler ();
return 0;
}
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG