Tastiera - Giobe®2000 - Assembler / Assembly tasti ps2 buffer circolare ctrl alt shift controllo funzionali

		DataSheet Visualizzatore LCD Tastiera Porta Parallela Porta Seriale Stampanti Timer di Sistema Sottosistema Video Cursore RamVideo INDICE TEMI

Tastiera

PER TUTTI [1 di 11]

^{LA SEZIONE DEDICATA ALLA
TASTIERA
E' STATA VISITATA} Hit Counter

^VOLTE...

Consiglia questo Tutorial agli amici con Google+1

Aggiornato 22 agosto 2005

	Il problema della lettura della Tastiera o dell'attesa della pressione di tasti, è fondamentale per la gestione interattiva dei programmi, tipica di un menu, di un gioco o di qualunque altro applicativo che lascia decidere all'utente.
	Questa Sezione è nata, per ora, sostanzialmente a beneficio e sostegno delle procedure Pascal della Libreria Giobe.TPU; per questo i contenuti sono sostanzialmente orientati a questo linguaggio di programmazione
	In un prossimo futuro verrà integrata anche all'Assembly.

In Pascal, l’istruzione Repeat Until keypressed obbliga il processore a ripetere finché non risulta premuto un tasto, per cui sembra adatta al nostro scopo.

L'istruzione Repeat Until keypressed, sebbene sembri logicamente perfetta (almeno "alla lettera") si dimostra in pratica una delusione. Chiamata più volte di seguito nel medesimo programma funziona (cioè si ferma in attesa) solo la prima volta (provare per credere...).

Una più attenta lettura dell'istruzione giustifica questo atteggiamento: la variabile di sistema keypressed è di tipo logico. Per default essa è falsa fino a che non viene premuto un tasto, per cui non appena ciò accade se non si provvede a ripristinarla (con keypressed:=false) rimarrà vera per sempre e, ad una successiva proposta Repeat Until keypressed, il programma non si fermerà più.

Dalla pressione di un tasto all'effetto da essa provocato la strada è lunga e articolata:

	comincia dentro la tastiera, dove il processore dedicato scorre freneticamente sotto ogni tasto per sentire se è premuto (o rilasciato); quando ciò accade spedisce al computer un numero, il codice di scansione, tipico della posizione di ciascun tasto (per esempio <ESC>, in alto a sinistra, ha il numero 1).
	l'interfaccia interna al computer si occupa di affiancare a questo numero il corrispondente codice ascii, prelevato dalla tabella nazionale associata alla tastiera dal comando Dos KEYB (per esempio KEYB IT)
	dopo questa operazione i 2 bytes generati per il tasto premuto sono scritti in una area di memoria ram condivisa con il sistema operativo, detta *Buffer Circolare* .
	poiché il sistema operativo non può, di norma, rimanere insensibile alla pressione di un tasto, provvede a "scaricare" il *Buffer Circolare, cioè legge* da esso la coppia di bytes, cedendoli all'applicativo che ne ha fatto richiesta
	di solito l'applicativo (ma anche il sistema stesso, se aspetta un tasto di sua iniziativa, per esempio al prompt del Dos) spedisce i bytes alle procedure di stampa a video, che si occupano di far apparire il carattere corrispondente nella posizione di stampa corrente
	tra gli applicativi, Turbo Pascal scarica il buffer circolare con la funzione readkey.

In altri termini non basta leggere la tastiera (cioè fermarsi in attesa della pressione di un tasto). Bisogna anche "consumare" il tasto premuto, assumendone il codice Ascii dalla variabile di sistema readkey in una adeguata variabile personale di tipo char, per esempio tasto.

L'istruzione Repeat Until keypressed non basta per leggere la tastiera. Subito dopo deve essere eseguita anche l’istruzione tasto:=readkey. Tra l'altro la variabile tasto da noi definita, di tipo char, ci permette di scegliere diverse opzioni, in funzione del suo valore, associato a quello del tasto premuto.

In conclusione per leggere la tastiera conviene usare solo l’istruzione tasto:=readkey; essa non solo obbliga il programma a fermarsi fino all'avvenuta pressione, ma lascia anche il codice Ascii del tasto premuto nella nostra variabile tasto.

Come anticipato il sistema assume con facilità il codice Ascii dal Buffer Circolare della tastiera; ma rimane ancora oscura la ragione per cui esso provvede ad annotare anche il secondo byte, cioè codice di scansione.

	Ciò ci autorizza ad anticipare un'altra magia: il curioso lettore si sarà certo chiesto in che modo vengono "consumati" i tasti non associati a lettere o numeri o, in genere, a caratteri stampabili.
	Essi sono numerosi: la serie da F1 a F12; i tasti della tastierina a destra, come PgUp, Home, Canc, Ins e le frecce; tutti questi tasti si possono genericamente chiamare tasti funzionali.

L'ambiente di programmazione Turbo Pascal non sembra consentire la gestione dei tasti funzionali, come F1, PgUp, Home, le frecce, ecc.

Il servizio dei tasti funzionali è dunque possibile e facile. Basta ricordare che:

	hanno in comune la caratteristica di avere codice Ascii uguale a zero, per cui se dopo l'istruzione *tasto:=readkey; essa lascia tasto=#0 cioè tasto=char(0)*** il tasto premuto è sicuramente di tipo funzionale
	in questo caso basta eseguire di nuovo *tasto:=readkey; nella variabile tasto* è ora lasciato il codice di scansione, cioè un numero tipico del tasto funzionale premuto

La gestione dei tasti, in Pascal, deve dunque rispettare il fatto che per ogni tasto sono accreditabili 2 byte:

per la maggior parte di essi, i tasti standard, (lettere, numeri, segni di interpunzione) è significativo il codice Ascii, che è poi quello che viene stampato a video alla sua pressione. In questo caso il codice di scansione non ha alcun significato. basta analizzare il loro codice Ascii, dichiarandolo tra apici:

Tasti Standard

......
REPEAT
tasto:=readkey;
IF Upcase(tasto)='A' Then ServizioTastoA;
UNTIL (UpCase(tasto)='Q') OR (tasto=#27);
......

Il codice proposto per esempio legge la tastiera (tasto:=readkey;) e controlla 3 tasti; con 'A' esegue la procedura ServizioTastoA; con 'Q' oppure con Esc (tasto=#27) esce dal Loop di attesa tasti. Analizzando con attenzione il codice possiamo sottolineare:

la tecnica per metterci al riparo dal "rischio minuscola": rendendo comunque maiuscola la variabile tasto (con UpCase) è possibile garantire il servizio sulle lettere anche se la tastiera le gestisce in minuscolo

è possibile analizzare il codice Ascii del tasto premuto anche mediante il suo valore numerico: il prefisso # davanti al numero produce lo stesso effetto del comando Pascal Char (per esempio: 'Q' = char(81) = #81)

questa tecnica è ideale per i tasti di controllo, privi di caratteri Ascii significativi, come appunto Esc (=#27=Char(27)) oppure per esprimere i codici di scansione dei tasti funzionali (come vedremo tra poco).

NB: l'espressione #numero; è di tipo carattere ed equivale a char(numero);

per i tasti rimanenti, i tasti funzionali (F1, F2, ..., PgUp, PgDn, ..., Home, End, le 4 frecce, ..., Ins, Del, ...) il codice Ascii, è sempre uguale a zero; per ciò l'unico modo per distinguerli tra loro è quello di utilizzare il codice di scansione.

Tasti Funzionali

......
REPEAT
    tasto:=readkey;
    IF tasto=#0 Then
    begin
      tasto1:=readkey;
      IF tasto1=#72 Then ServUp; {freccia in   ALTO }
      IF tasto1=#80 Then ServDn; {freccia in   BASSO }
      IF tasto1=#77 Then ServDx; {freccia a DESTRA }
      IF tasto1=#75 Then ServSn; {freccia a SINISTRA}
    end;
......
UNTIL (UpCase(tasto)='Q') OR (tasto=#27);
......

Il codice proposto per esempio legge la tastiera (tasto:=readkey;) e controlla 6 tasti; con 'Q' oppure con Esc (=#27) esce dal Loop di attesa tasti, mentre se è premuto un tasto funzionale (Ascii= 0, cioè tasto=#0) esegue la procedura di servizio predisposta per ciascuna delle 4 frecce, rispettivamente associate ai codici di scansione #72 (freccia in alto), #80 (freccia in basso), #77 (freccia a destra) e #75 (freccia a sinistra).

NB: naturalmente l'uso di 2 variabili di tipo Char, tasto e tasto1, invece di una può legittimamente essere ritenuto esagerato: poichè non costa nulla può essere comunque utile differenziare le 2 risposte dalla tastiera, essendo fisicamente associate a 2 tipologie di codici, ascii il primo e di scansione il secondo.

Nella SottoSezione dedicata agli Applicativi del Pascal è possibile trovare diversi programmi che mettono in atto questa tecnica: per tutti possiamo consultare il codice sorgente del programma PacMan.

Nella gestione dei tasti letterali si nasconde un pericolo subdolo che produce un frustrante senso di impotenza; può succedere che il nostro programma preveda di terminare con la pressione del tasto 'Q' e che, sebbene sembri l'ottava meraviglia, non abbia alcuna intenzione di uscire.
La soluzione è banale ma dolorosa: ci siamo dimenticati che esiste un tasto che predispone la stampa a video delle lettere in maiuscolo e/o in minuscolo.
Poichè lo stato di questo commutatore è imprevedibile mentre il programma sta 'girando' è sufficiente forzare maiuscole le eventuali minuscole con il comando UpCase (vedi).

Consulta la Tabella dei Tasti per conoscere i valori dei 2 codici associati a ciascun tasto.

	Tastiera			PER TUTTI
	1 di 11

1 2 3 4 5 6 7 8 9 10 11

Tastiera »

Come Funziona.. | Download | INDICE

^Home

Pascal|Manuali|Tabelle|Schede
Tutorial Assembly|Palestra Assembler

Aggiungi Giobe®2000 ai preferiti

Motore
Ricerca

Rendi Giobe®2000 pagina di Default