• Objet : Définitions et explications des termes “terminal” et “console”
• Niveau requis :

  débutant
• Commentaires : Contexte d'utilisation du sujet du tuto.
• Débutant, à savoir : Utiliser GNU/Linux en ligne de commande, tout commence là !.
• Suivi :

  en-chantier
  • Création par agp91 21/04/2023
  • Testé par <…> le <…>
• Commentaires sur le forum : Lien vers le forum concernant ce tuto ¹⁾

Nota :

Contributeurs, les sont là pour vous aider, supprimez-les une fois le problème corrigé ou le champ rempli !

Pour différencier les différents types d'interfaces en mode texte, nommées aussi interfaces de ligne de commande ou CLI (Commande Line Interface) qui sont mises à notre disposition, nous utilisons communément deux termes :

• La console qui désigne, les interfaces que nous obtenons par la combinaison des touche Ctrl+Alt+F1 à F6 (sur les systèmes Debian GNU/Linux modernes).
• Le terminal, pour désigner dans un environnent graphique, la fenêtre, où nous obtenons une interface en mode texte.

Cela est simple et précis.
Mais quand nous souhaitons aller plus loin, c'est réducteur et peut porter à confusion.

Par exemple, lorsque que nous lisons la page du manuel du terminal fenêtre xterm, nous pouvons y lire :

Extrait de la page du manuel d'xterm

XTERM(1)           X Window System                   XTERM(1)
 
NAME
       xterm - terminal emulator for X

Ici, même si terminal est qualifié d'émulateur pour X, nous pouvons encore comprendre.

Mais lorsque nous ouvrons la page du manuel de la commande agetty.
Qui est le programme, qui nous permet d'obtenir les six consoles, disponibles par les combinaisons des touches, Crtl+Alt+F….
Nous pouvons y lire :

Extrait de la page du manuel d'agetty

AGETTY(8)       Administration Système             AGETTY(8)
 
...
 
DESCRIPTION
       agetty  ouvre  un  port  de  terminal...

Nous comprenons donc là, qu'un terminal est aussi autre chose, qu'une interface fenêtre dans un environnement graphique.
Ce qui étonne, c'est que, ne soit pas utilisé le terme console.

Alors, nous décidons d’élargir nos connaissances. Et après une longue immersion dans l'Internet.
Notre vocabulaire se trouve grandement amélioré :

• Console, console physique, console Linux, console système, console virtuelle, console texte, console graphique,
• Terminal, terminal physique, terminal Linux, émulateur de terminal, terminal virtuel, terminal texte, terminal intelligent (par-ce qu'il y a des terminaux sots ? ), terminal muet, pseudo-terminal, terminal graphique, terminal X, terminal fenêtre, multiplexeur de terminal, terminal série…
• TTY, PTY

Même si certaines de ces dénominations sont compréhensibles par leurs qualificatifs. Par exemple : Consoles/terminaux texte (qui n'utilisent que du texte), consoles/terminaux graphique (qui peuvent afficher des images).

… Il se peut, que nous ne comprenons plus rien, tant les définitions trouvées sont disparates et même contradictoires.
Nous commençons à regretter le temps, où il nous semblait, que nous avions tout compris avec seulement deux définitions.

Pouvons-nous utiliser indifféremment les mots terminal et console, comme nous le souhaitons ?

Non, évidement que non !

Il est proposé dans cette page de wiki, de revenir aux définitions (parfois historiques), qui permettent de désigner chacun des éléments de nos système.
Et ainsi apporter éclaircissement dans la confusion.

Plus bas, il est parfois fait référence à la documentation des sources du noyau, écrite par Linus Torvalds.
Étant sous systèmes GNU/Linux, avec un noyau Linux, de et dirigé par Linus Torvalds,
C'est donc lui, ici, qui aura le dernier mot.

Allons-y, retour aux sources.

Un terminal est un appareil qui dispose simplement d'une entrée et d'une sortie. Connecté directement à un ordinateur (central), ou par réseau, il permet de communiquer avec ce dernier. De lui envoyer des informations (l'entrée) et d'en communiquer le retour (la sortie).

Les terminaux sont des points finaux (terminus) d'un réseau. Après eux, il y a nous.

Actuellement, les terminaux disposent presque tous d'un clavier comme entrée (et/ou d'un pointeur, souvent une souris). Et pour sortie un écran.
Aux débuts de l'informatique, la sortie était une imprimante, avec un rouleau de papier.

La saisie depuis l'entrée d'un terminal (par exemple, un clavier), est envoyée à l'ordinateur, qui traite l'information et retourne le résultat sur la sortie du terminal.

Sur un terminal, aucun programme n'est exécuté, ils sont exécutés sur l'ordinateur. Le terminal est utilisé uniquement, comme point d'entrée/sortie pour communiquer avec le programme distant.

Un terminal d'impression, parfois nommé terminal papier, est un terminal doté d'un clavier en entrée et d'une imprimante en sortie. Les premier étaient nommés téléimprimeurs ou téléscripteurs.

En plus du clavier (ou pas), certains disposaient (aussi) en entrée, d'un lecteur de carte perforée. Et d'une perforeuse en sortie. Permettant ainsi la sauvegarde et la restauration de l'ordinateur central.

Un terminal vidéo est un terminal dont la sortie est un écran vidéo. Ils remplacèrent avantageusement les terminaux d'impressions.

Un terminal mode caractère ou mode octet ou mode brut (raw mode), communique avec l'ordinateur caractère/octet par caractère/octet.

Un jeux de caractère prédéfinit (par exemple le code ASCII) est utilisé. Ces jeux de caractère disposent de quelques caractères de contrôle tel que la tabulation, l’effacement arrière d'un caractère, le saut de ligne, etc.

Par exemple, avec le jeux de caractère ASCII, les caractères sont codés de 0 à 127. Les 32 premiers (de 0 à 31) et le dernier (127), sont des caractères de controle²⁾.

Un caractère saisi au clavier est envoyé à l'ordinateur, le quel, soit :

• Le retourne au terminal :
  • S'il s’agit d'un caractère imprimable, il est affiché à l'écran.
  • S'il s’agit d'un caractère de contrôle (non imprimable), le terminal applique son interprétation à l'écran.
• Si le caractère est un caractère de contrôle qui met fin à l'écriture d'une commande. Il retourne au terminal, caractère par caractère, le résultat de la commande.

Pratiquement chaque terminal dispose de son(/ses) propre(s) jeu(x) de caractère, incluant plus ou moins des caractères de contrôle.

Avec l'évolution du matériel, le nombre de caractère de contrôle, a pu être augmenté, en utilisant des séquences de caractère, nommées séquences d'échappement.
Ces séquences débutent par un caractère d'échappement. Comme par exemple le caractère ANSI ESC (ESCape).
Les séquences d'échappement ANSI³⁾ en sont un aboutissement standardisées.

Avec encore plus de matériel embarqué, en particulier de la mémoire et parfois un processeur. Les terminaux mode ligne sont apparus.

En mode ligne, nommé aussi mode canonical, la communication avec l'ordinateur se réalise ligne de caractère par ligne de caractère.

Chaque caractère d'une ligne est conservé dans un tampon, tout en étant affiché à l'écran pour l'édition.
La ligne n'est envoyée à l'ordinateur, qu'après l'usage du caractère de fin de ligne ou fin de bloc.

(stackexchange)(en) Mode ligne de l'IBM 1050 (Traduction) : L'IBMs 1050⁴⁾ , un terminal d'impression, introduit en mars 1963, a divergé (le premier?) des TTY ⁵⁾ avec les E/S à caractère unique, non synchronisés, en introduisant le mode ligne. Le Control Unit 1051⁶⁾ gérait un tampon de ligne. Alors que chaque frappe était directement affichée, une ligne n'était envoyée à l'unité centrale que lorsque EOB (End Of Block) était pressé. Un saut de ligne, impliquait un EOB. Après l'envoi, le clavier était verrouillé, jusqu'à ce qu'il soit libéré par l'unité centrale.

Les terminaux mode bloc ont encore étendus les fonctionnalités d'édition. Libérant avantageusement l'ordinateur et de la bande passante du réseau. Ainsi plus de terminaux pouvaient être connecté à l'ordinateur.

Le tampon contient un bloc (une matrice) de caractère, souvent la page entière de l'écran. Permettant ainsi, par exemple d'envoyer à l'ordinateur un formulaire entier. L'ordinateur retourne alors le rafraîchissement de l'écran (la page) à afficher.

Le mode bloc peut être utilisé par les terminaux graphique, pour afficher des graphismes et des images.

Un terminal texte, qu'il soit en mode caractère, en mode ligne ou en mode bloc, n'affiche que du texte.

Pourtant il est possible de réaliser des graphismes rudimentaires en utilisant les caractères, pour former des fenêtres, des boites de dialogues, etc..

Certains terminaux texte disposent de jeu de caractères semi-graphique⁸⁾. Dont les matrices, ne sont pas des caractères mais des graphiques. Avec des séquences d'échappement, il est même possible de réaliser des animations⁹⁾.

 _______________
< Debian Facile >
 ---------------_______________
   \   .--.    < mouoai facile >
    \ |o_o |    ---------------
      |:_/ |      \   ^__^
     //   \ \      \  (oo)\_______
    (|     | )        (__)\       )\/\
   /'\_   _/`\            ||----w |
   \___)=(___/            ||     ||

Un terminal graphique est un terminal mode bloc, qui permet d'afficher du texte, des graphiques et des images.

Terminal passif ou terminal muet est la traduction sobre de dumb terminal. D'autres traductions peuvent apparaître : stupide, sot, idiot, etc..

Terminal intelligent est la traduction de intelligent terminal ou smart terminal

La signification de ces termes ont évolué dans le temps. Au fur et à mesure que les terminaux embarquaient plus de matériel. Offrant plus de fonctionnalité.

Au départ, les terminaux passifs étaient les terminaux mode caractère, qui n'offrent aucune fonction d'édition et qui sollicitent l'ordinateur, dés lors qu'une touche est appuyée.

A contrario, les terminaux intelligent déchargeaient l'ordinateur des taches de saisie et/ou d'affichage (séquences d'échappement, mode ligne, mode bloc, affichage de graphisme).

De nos jours, est aussi nommé terminal intelligent, un client léger. Ou un client lourd, qui participe aux traitements des données (par exemple lorsque qu'il retourne une somme qu'il a lui même calculé).

D'un point de vu marketing, une distinction est faite entre les terminaux smart, qui regroupent ceux qui soulagent l'ordinateur de l'édition et de l'affichage. Et les terminal intelligent, qui regroupent les clients lourds.

Voir aussi :

Le terminal intelligent par l'historique IBM : (stackexchange)(en) Questions : When did smart terminals arrive ?

• Terminal passif (dumb terminal) : (fr.wikipedia) Terminal passif - (wikipedia)(en) Computer terminal : Dumb terminal - (oxfordreference)(en) Dumb terminal - (webopedia)(en) Dumb terminal
• Terminal intelligent (intelligent terminal) : |(wikipedia)(en) Computer terminal : Intelligent terminal - (oxfordreference)(en) Intelligent terminal (1) - (oxfordreference)(en) Intelligent terminal (2) - (webopedia)(en) Intelligent terminal
• Terminal smart (smart terminal) : (wikipedia)(en) Smart terminal - (webopedia)(en) Smart terminal

Une console, nommée aussi console système ou pupitre de commande, est une machine, un terminal, qui a un accès particulier (privilégier) à l'ordinateur central.

Elle permet la communication avec cet ordinateur, depuis son démarrage.
Les messages du système, y sont affichés.

C'est à travers elle, que peut-être administrer l'ordinateur.
Par exemples : Installer le système d'exploitation ; Configurer le noyau ; Passer des options durant le démarrage ; Installer et configurer les services ; Etc.

Ainsi, une console (système), se distingue d'un simple terminal, qui lui, ne fait que se connecter à l'un des services démarré sur l'ordinateur.

Un émulateur de terminal est un programme qui émule une machine terminal.

Nos ordinateurs (PC) ne sont pas des terminaux, mais avec les ressources qu'ils disposent, ils peuvent à travers un programme, émuler le comportement d'un terminal.

Un ordinateur hôte, ne fait pas la différence entre une machine terminal et un terminal émulé.

TTY est l'acronyme TeleTYpe¹²⁾, un téléimprimeur commercialisé en 1953 par la sociètée Teletype Corporation¹³⁾, filiale de Western Electric Compagny¹⁴⁾, rachetée par AT&T¹⁵⁾ en 1930.

Plus simplement, d'un point de vue système, TTY signifie terminal (puisqu'un Teletype est un terminal).

Des définitions données ci-dessus, nous pouvons retenir :

• Un terminal est un appareil disposant d'une entrée (un clavier) et d'une sortie (une imprimante, un écran, etc).
• Un terminal vidéo est un terminal disposant d'un écran vidéo.
• Une console système ou une console est un terminal connecté à un ordinateur, qui affiche les messages du système de cet ordinateur. Et qui permet de le configurer depuis le démarrage.
• Un terminal texte est un terminal qui n'affiche que du texte.
• Un terminal graphique est un terminal qui affiche du texte et des images.
• Un émulateur de terminal ou un terminal émulé est un programme qui émule un terminal.
• TTY signifie terminal.

Au début de l'informatique, pour communiquer avec les ordinateurs, les téléimprimeurs ont été utilisés pour fournir une entrée et une sortie. Les téléimprimeur ont évolué en terminal vidéo.

Schématiquement, nous avions ceci :

 +------------Matériel---------------+
 |                         +---------|--------------------------Ordinateur----------------------------+
 | +----Terminal----+      |         |  +--------------------------Logiciel-------------------------+ |
 | | +-------+      |      |         |  +------------------Espace-Noyau------------+-----Espace-----+ |
 | | |Sortie |<--+  |      |  +---+  |  |  +-------+    +----------+    +-------+  |  +-----------+ | |
 | | +-------+   |  |      |  | U |  |  |  |       |    |          |    |       |<=|=>| Processus | | |
 | |             +<=|==//==|=>| A |<=|==|=>|Drivers|<==>|Discipline|<==>|Drivers|  |  +-----------+ | |
 | | +-------+   |  |      |  | R |  |  |  | UART  |    | de ligne |    |  TTY  |  |  +----------+  | |
 | | |Clavier|->-+  |      |  | T |  |  |  |       |    |          |    |       |<=|=>|  P...    |  | |
 | | +-------+      |      |  +---+  |  |  +-------+    +----------+    +-------+  |  +----------+  | | 
 | +----------------+      |         |  +------------------------------------------+---utilisateur--+ |
 +-------------------------|---------+                                                                |
                           +--------------------------------------------------------------------------+

Un téléscripteur (un terminal), qui ici, pourrait être une console (système), est connecté par un câble (une paire de fils) à l'ordinateur.

• Lorsque le terminal envoie le signal d'un caractère pressé au clavier. Il est reçu par un composant électronique de l'ordinateur, nommé UART (Universal Asynchronous Receiver Transmitter)¹⁷⁾ et ses drivers. Ce qui transforme le signal de la transmission série¹⁸⁾ en une transmission parrallèle¹⁹⁾ et en octet.
• L'octet est transmis à la discipline de ligne, qui dispose d'un tampon d'édition et de quelques fonctions rudimentaires d'édition.
  • Par exemple :
    • Un caractère tapé, est transmis à la discipline de ligne. Il est ajouté au tampon et renvoyé vers la sortie du terminal, pour affichage/impression.
    • … Mais nous souhaitons le supprimer. Alors depuis le terminal, nous envoyons le caractère de contrôle d’effacement arrière.
    • Arrivé dans la discipline de ligne, le tampon et la sortie du terminal sont mis à jour (effacement du dernier caractère).
    • → Ainsi, ni le caractère, ni l'ordre de l’effacer, ne sont envoyés aux drivers TTY.
• La discipline de ligne envoie, aux drivers TTY, le contenu de son tampon, que lorsque le caractère de fin de ligne est reçu.
• En ce sens, la discipline de ligne travail en mode ligne (ce comportement peut-être évidement modifié pour un autre mode).
• Puis, les drivers TTY se chargent de transmettre, la séquence reçue de la discipline de ligne, au processus approprié.

Depuis,
Avec l’évolution, les ordinateurs sont dans nos maisons. Pour que nous puissions communiquer avec eux, ils émulent, avec les ressources qu'ils disposent (mémoire et microprocesseurs), un terminal. L'entrée et la sortie de ce terminal sont, le clavier et l'écran (seul matériel restant des téléscripteur) et la souris. Ils sont directement connecter à l'ordinateur.

Poursuivons…

Dans un système GNU/Linux, la console Linux émule un terminal au sein du noyau.

Elle permet d'utiliser le clavier et l'écran comme un terminal (ou plutôt comme une console).

C'est l'interface que nous disposons lors du démarrage (boot) de l'ordinateur ou lorsque nous démarrons en mode mono-utilisateur (ou mode dépannage).

Linux Torvald, dans les sources du noyau à écrit :

(git.kernel)(en) Torvalds/Linux/drivers/tty/Kconfig (traduction) : La console système est le périphérique qui reçoit tous les messages du noyau et des avertissements et qui permet les connexions en mode mono-utilisateur.

Ainsi la console Linux est la console de l'ordinateur. Elle est, ce qu'est une console système pour l'ordinateur central.

Elle n'existe que dans le noyau et le matériel.

                 +------------------------Logiciel--------------------------+
                 +---------------------Espace-noyau-------------------------+
 +------------Console-----------------------------------------------------+ |
 | +-Matériel-+  |  +-------+   +---------+    +----------+    +-------+  | |
 | | +-----+  |  |  |Drivers|   |         |    |          |    |       |  | |
 | | |Ecran|<-|--|--| vidéo |<--|Emulateur|    |Discipline|    |Drivers|  | |
 | | +-----+  |  |  +-------+   |   de    |<==>|          |<==>|       |  | |
 | |+-------+ |  |  +-------+   |terminal |    | de ligne |    |  TTY  |  | |
 | ||Clavier|-|--|->|Drivers|-->|         |    |          |    |       |  | |
 | |+-------+ |  |  |Clavier|   +---------+    +----------+    +-------+  | |
 | +----------+  |  +-------+                                             | |
 +---------------|--------------------------------------------------------+ |
                 +----------------------------------------------------------+

• Le matériel UART et ses drivers ont disparu, laissant la place aux drivers vidéo et clavier.
• L'émulateur de terminal est désigné comme terminal physique.

Avec les systèmes GNU/Linux modernes, sur un PC et un écran moderne, la console est un terminal graphique.

La documentions du noyau indique :

(kernel)(en) Documentation : fbcon.txt (traduction) : La console framebuffer (fbcon), comme son nom l’indique, est une console de texte exécutée au-dessus du périphérique framebuffer. Il a les fonctionnalités de n’importe quel pilote de console de texte standard, tel que la console VGA, avec les fonctionnalités supplémentaires qui peuvent être attribuées à la nature graphique du framebuffer.

Le noyau des systèmes Debian GNU/Linux récents, dispose des drivers framebuffer, par défaut.

Les terminaux virtuels sont le “multiplexage” de la console Linux. Ils Rendent accessible la console dans l'espace utilisateur.

Linux Torvald, dans les sources du noyau à écrit :

(git.kernel)(en) Torvalds/Linux/drivers/tty/Kconfig (traduction) : Si vous dites Y ici, vous obtiendrez un support pour les terminaux avec des périphériques d’affichage et de clavier. Celles-ci sont dites « virtuelles » car vous pouvez exécuter plusieurs terminaux virtuels (également appelés consoles virtuelles) sur un terminal physique… Vous avez besoin d’au moins un terminal virtuel pour utiliser votre clavier et votre moniteur.

Virtualisant la console, ils sont aussi nommés consoles virtuelles.

Un système Debian GNU/Linux moderne, permet d'utiliser 63 terminaux virtuels.
Dont 6 sont accessibles avec la combinaison des touches Ctrl+Alt+F1 à F6.
Et sont nommés respectivement tty1 à tty6.

                 +--------------------------------Logiciel----------------------------------+
                 +---------------------Espace-noyau----------------+---Espace-utilisateur---+
 +------------Console--------------------------------------------+ | +----VT-----+          |
 | +-Matériel-+  |  +-------+   +---------+   +---+   +-------+  | | |  +-----+  |  +-----+ |
 | | +-----+  |  |  |Drivers|   |         |   |   |   |       |<=|=|=|=>|tty1 |<=|=>|shell| |
 | | |Ecran|<-|--|--| vidéo |<--|Emulateur|   | D |   |Drivers|  | | |  +-----+  |  +-----+ |
 | | +-----+  |  |  +-------+   |   de    |<=>| D |<=>|       |  | | |           |          |
 | |+-------+ |  |  +-------+   |terminal |   | L |   |  TTY  |  | | |  +-----+  |  +-----+ |
 | ||Clavier|-|--|->|Drivers|-->|         |   |   |   |       |<=|=|=|=>|tty2 |<=|=>|shell| |
 | |+-------+ |  |  |Clavier|   +---------+   +---+   +-------+  | | |  +-----+  |  +-----+ |
 | +----------+  |  +-------+                                    | | |  ...      |          |
 +---------------|-----------------------------------------------+ | +-----------+          |
                 +-------------------------------------------------+------------------------+
DDL : Discipline de ligne
VT : Terminal virtuel

Les systèmes GNU/Linux sont multi-utilisateurs. Cet avantage permet d'utiliser plusieurs terminaux virtuels avec, si nous le désirons, un utilisateur différent.

Même si plusieurs terminaux virtuels peuvent être ouvert, un seul uniquement, peut être au premier plan.

Sur un système non graphique, après son démarrage, la sortie du premier terminal virtuel est affiché à l'écran.
Le programme agetty, qui à créé dans l'espace utilisateur, le terminal virtuel tty1, sanctionne son accès, en demandant un nom d'utilisateur.
Pour aller plus loin, nous devons saisir notre nom d'utilisateur, suivit de la touche entrée.
Une fois fait, le programme agetty est remplacé par le programme login, qui nous demande notre mot de passe.
(Durant la saisie du mot de passe, aucun caractère n'est affiché. C'est normal, cela empêche à que d'autres puissent lire notre mot de passe durant sa saisie.)
S'il est exacte, nous sommes connectés. Le programme renseigné dans le champ shell, du fichier /etc/passwd (souvent bash) est exécuté.

Avec la venue des interfaces graphiques, il fut nécessaire (utile) de disposer de programme proposant dans une fenêtre, un terminal.
Ces programmes sont nommés terminaux fenêtre ou fenêtres de terminal.
Ils émulent dans une fenêtre, un terminal texte ou un terminal graphique.

Sur les systèmes Debian GNU/Linux, l'interface graphique est disponible sur le 7em terminal virtuel (Ctrl + Alt + F7).

Ainsi, lors du démarrage du système, le 7em terminal virtuel est affiché.
Son usage est sanctionné par un login graphique nommé gestionnaire de session graphique (login manager) ou gestionnaire d'affichage (display manager).
Pour aller plus loin, nous devons y saisir notre login de connexion (couple nom d'utilisateur + mot de passe).

Dès lors, lorsque nous ouvrons un terminal fenêtre, aucun login nous est demandé.
Nous sommes directement connectés avec notre nom d'utilisateur.
Le programme qui est renseigné dans le fichier /etc/passwd (souvent le shell bash) y est exécuté.

Nous pouvons ouvrir autant de terminaux fenêtre que nous avons besoin.

Pour émuler le comportement d'un terminal, les terminaux fenêtre n'utilise pas la console.
C'est un programme (un processus) en espace utilisateur qui émule le terminal. L'émulateur accède au matériel (le clavier et l'écran) par le serveur X.
L'émulation est rendue disponible pour un autre processus (par exemple un shell) en utilisant les pseudo-terminaux.

Ainsi, ils sont aussi nommés émulateur de terminal pour X ou terminal pour X (qu'il ne faut pas confondre avec les terminaux X).