Come funzionano l'input da tastiera e l'output di testo?

Supponiamo che io prema la A digita un editor di testo e questo inserisce il carattere a nel documento e lo visualizza sullo schermo. So che l'applicazione dell'editor non sta comunicando direttamente con l'hardware (c'è un kernel e altre cose nel mezzo), quindi cosa sta succedendo all'interno del mio computer?

Risposta accettata:

Ci sono diversi scenari; Descriverò i più comuni. Gli eventi macroscopici successivi sono:

Input:l'evento di pressione del tasto viene trasmesso dall'hardware della tastiera all'applicazione.
Elaborazione:l'applicazione lo decide perché la chiave A è stato premuto, deve visualizzare il carattere a .
Output:l'applicazione dà l'ordine di visualizzare a sullo schermo.

Applicazioni GUI

L'interfaccia utente grafica standard de facto dei sistemi Unix è il sistema X Window, spesso chiamato X11 perché stabilizzato nell'undicesima versione del suo protocollo principale tra le applicazioni e il server di visualizzazione. Un programma chiamato X server si trova tra il kernel del sistema operativo e le applicazioni; fornisce servizi che includono la visualizzazione di finestre sullo schermo e la trasmissione di pressioni di tasti alla finestra che ha il focus.

Inserimento

+----------+              +-------------+         +-----+
| keyboard |------------->| motherboard |-------->| CPU |
+----------+              +-------------+         +-----+
             USB, PS/2, …                 PCI, …
             key down/up

Innanzitutto, le informazioni sulla pressione e il rilascio del tasto vengono trasmesse dalla tastiera al computer e all'interno del computer. I dettagli dipendono dal tipo di hardware. Non mi soffermerò più su questa parte perché le informazioni rimangono le stesse per tutta questa parte della catena:un certo tasto è stato premuto o rilasciato.

         +--------+        +----------+          +-------------+
-------->| kernel |------->| X server |--------->| application |
         +--------+        +----------+          +-------------+
interrupt          scancode             keysym
                   =keycode            +modifiers

Quando si verifica un evento hardware, la CPU attiva un interrupt, che causa l'esecuzione di codice nel kernel. Questo codice rileva che l'evento hardware è la pressione di un tasto o il rilascio di un tasto proveniente da una tastiera e registra il codice di scansione che identifica la chiave.

Il server X legge gli eventi di input tramite un file del dispositivo, ad esempio /dev/input/eventNNN su Linux (dove NNN è un numero). Ogni volta che si verifica un evento, il kernel segnala che ci sono dati da leggere da quel dispositivo. Il file del dispositivo trasmette eventi chiave su/giù con un codice di scansione, che può essere o meno identico al valore trasmesso dall'hardware (il kernel può tradurre il codice di scansione da un valore dipendente dalla tastiera a un valore comune e Linux non 'non ritrasmettere i codici di scansione che non conosce).

X chiama il codice di scansione che legge un codice chiave . Il server X mantiene una tabella che traduce i codici chiave in keysyms (abbreviazione di "simbolo chiave"). I codici chiave sono numerici, mentre i simboli chiave sono nomi come A , aacute , F1 , KP_Add , Control_L , … Il keysym può variare a seconda dei tasti modificatori premuti (Maiusc , Ctrl , …).

Esistono due meccanismi per configurare la mappatura da keycode a keysyms:

xmodmap è il meccanismo tradizionale. È una semplice tabella che mappa i codici chiave a un elenco di keysyms (non modificati, spostati, ...).
XKB è un meccanismo più potente, ma più complesso con un migliore supporto per più modificatori, in particolare per la configurazione a doppia lingua, tra gli altri.

Le applicazioni si connettono al server X e ricevono una notifica quando viene premuto un tasto mentre una finestra di quell'applicazione è attiva. La notifica indica che un determinato keysym è stato premuto o rilasciato e quali modificatori sono attualmente premuti. Puoi vedere keysyms eseguendo il programma xev da un terminale. Ciò che l'applicazione fa con le informazioni dipende da essa; alcune applicazioni hanno associazioni di tasti configurabili.

In una configurazione tipica, quando si preme il tasto etichettato A senza modificatori, invia il keysym a alla domanda; se l'applicazione è in una modalità in cui stai digitando del testo, questo inserisce il carattere a .

La relazione tra layout della tastiera e xmodmap entra più in dettaglio sull'input da tastiera. Come funzionano gli eventi del mouse in Linux? offre una panoramica dell'input del mouse ai livelli inferiori.

Uscita

+-------------+        +----------+          +-----+         +---------+
| application |------->| X server |---····-->| GPU |-------->| monitor |
+-------------+        +----------+          +-----+         +---------+
               text or              varies          VGA, DVI,
               image                                HDMI, …

Esistono due modi per visualizzare un carattere.

Rendering lato server :l'applicazione dice al server X "disegna questa stringa in questo carattere in questa posizione". Il carattere risiede sul server X.
Rendering lato client :l'applicazione crea un'immagine che rappresenta il carattere in un font scelto, quindi dice al server X di visualizzare quell'immagine.

Correlati:utilizzare una password per proteggere un file di testo?

Vedi Quali sono gli scopi dei diversi tipi di font XWindows? per una discussione sul rendering del testo lato client e lato server in X11.

Ciò che accade tra il server X e l'unità di elaborazione grafica (il processore sulla scheda video) dipende molto dall'hardware. I sistemi semplici hanno il server X disegnato in una regione di memoria chiamata framebuffer, che la GPU raccoglie per la visualizzazione. Sistemi avanzati come quelli che si trovano su qualsiasi PC o smartphone del 21° secolo consentono alla GPU di eseguire alcune operazioni direttamente per prestazioni migliori. In definitiva, la GPU trasmette il contenuto dello schermo pixel per pixel ogni frazione di secondo al monitor.

Applicazione in modalità testo, in esecuzione in un terminale

Se il tuo editor di testo è un'applicazione in modalità testo in esecuzione in un terminale, allora è il terminale che è l'applicazione ai fini della sezione precedente. In questa sezione spiego l'interfaccia tra l'applicazione in modalità testo e il terminale. Per prima cosa descrivo il caso di un emulatore di terminale in esecuzione su X11. Qual è la differenza esatta tra un "terminale", un "shell", un "tty" e una "console"? può essere utile sfondo qui. Dopo aver letto questo, potresti voler leggere il molto più dettagliato Quali sono le responsabilità di ciascun componente Pseudo-Terminal (PTY) (software, lato master, lato slave)?

Inserimento

      +-------------------+               +-------------+
----->| terminal emulator |-------------->| application |
      +-------------------+               +-------------+
keysym                     character or
                           escape sequence

L'emulatore di terminale riceve eventi come "Left è stato premuto mentre Shift era giù". L'interfaccia tra l'emulatore di terminale e l'applicazione in modalità testo è uno pseudo-terminale (pty) , un dispositivo a caratteri che trasmette byte. Quando l'emulatore di terminale riceve un evento di pressione di un tasto, lo trasforma in uno o più byte che l'applicazione legge dal dispositivo pty.

I caratteri stampabili al di fuori dell'intervallo ASCII vengono trasmessi come uno o più byte a seconda del carattere e della codifica. Ad esempio, nella codifica UTF-8 del set di caratteri Unicode, i caratteri nell'intervallo ASCII sono codificati come un singolo byte, mentre i caratteri al di fuori di tale intervallo sono codificati come più byte.

Pressioni di tasti che corrispondono a un tasto funzione o a un carattere stampabile con modificatori come Ctrl o Alt vengono inviati come sequenza di escape . Le sequenze di escape in genere sono costituite dal carattere escape (valore byte 27 =0x1B =