Les composants de base

L'électronique, c'est compliqué. Je vais donc user d'un exemple pédagogique sans danger pour les enfants : l'ordinateur pneumatique. Ce dernier ne possèdes que trois composants de base :


Les tuyaux

Un tuyau vide sera noté "0".
Un tuyau rempli d'air comprimé sera noté "1".




Les sources d'air comprimé

Tout tuyau au contact d'une source se voit rempli d'air comprimé.




Les inhibiteurs

Si l'on envoie de l'air comprimé dans l'inhibiteur, il bloquera la circulation dans le tuyau.




Exemple de circuit simplissime : le circuit inverseur.

Si l'entrée vaut 1, la sortie vaut 0.
Si l'entrée vaut 0, la sortie vaut 1.





La porte NAND

Une porte logique est un circuit possédant des tuyaux d'entrée et des tuyaux de sortie. L'état des sorties (0 ou 1) dépend de l'état des entrées (0 ou 1).

Observons par exemple la porte "NAND". Nous avons deux entrées (a et b) et une sortie (s).



Envisageons tous les cas possibles en entrée :


a = 0 et b = 0 :

On a alors s = 1.




a = 0 et b = 1 :

On a alors s = 1.




a = 1 et b = 0 :

On a alors s = 1.




a = 1 et b = 1 :

On a alors s = 0.




On résume ceci dans un tableau :



Ce tableau se nomme table de vérité. Il suffit à  décrire le fonctionnement la porte NAND. On peut donc la schématiser par une "boîte noire" :





Les autres portes logiques


On pourrait imaginer d'autres circuits, mais en pratique, ils coûte moins cher de produire uniquement des portes NAND. Voyons comment nous pouvons créer d'autres portes logiques à  partir de la porte NAND :

(Pour chacune, de gauche à  droite : sa représentation "boîte noire" // sa constitution interne // sa table de vérité)


La porte NON :

C'est le circuit inverseur vu plus haut.




La porte ET :

s vaut 1 si a et b valent 1.




La porte OU :

s vaut 1 si a ou b vaut 1 (ou les deux).




Vous pouvez vous amuser à  vérifier l'exactitude des tables de vérité ci-dessus, en utilisant celle de la porte NAND.



Exemple de circuit logique

En assemblant les diverses portes ci-dessus, on peut modéliser n'importe quel comportement, pourvu qu'il soit systématique. Prenons par exemple le fonctionnement de Raphaël "Raphaël Lafarge" Lafarge :

"Je sors de chez moi si j'ai un rencart, OU s'il y a un film intéressant au cinéma ET que je n'ai PAS de chapitre de Mirinar à  écrire."

En entrée, nous avons les affirmations suivantes :

"J'ai un rencart"
"Il y a un film intéressant au cinéma"
"J'ai un chapitre de Mirinar à  écrire"

En sortie, nous avons l'affirmation suivante :

"Je sors de chez moi"

Ces affirmation seront notées "1" (air comprimé) si elles sont vraies, et "0" (pas d'air comprimé) si elles sont fausses.

Le comportement décrit se résume donc au circuit suivant :



Pratique, n'est-il pas ? C'est le premier pas vers l'informatisation, et la création d'intelligences artificielles qui réduiront l'humanité en esclavage.

Et maintenant, vos appréciations et remarques, messieurs.

Le binaire

Compter en binaire, c'est exactement comme compter en décimal. A cela près qu'au lieu d'avoir dix chiffres (0, 1, 2, 3, 4, 5, 6, 7, 8, 9), on en a seulement deux (0, 1)

Nombre binaire => Nombre décimal correspondant

0000 => 0
0001 => 1
0010 => 2
0011 => 3
0100 => 4
0101 => 5
0110 => 6
0111 => 7
1000 => 8
1001 => 9
1010 => 10
1011 => 11
1100 => 12
1101 => 13
1110 => 14
1111 => 15


Additionner trois bits

Un bit est une variable pouvant prendre les valeurs 0 ou 1.
On prend donc trois bits a, b et c.

La somme de a, b et c (notée S) est le nombre de "1" que l'on compte parmis a, b, et c. Traduisons cela par un tableau qui recense tous les cas :

A, B, C => S (en décimal) => S (en binaire)

0, 0, 0 => 0 => 00
0, 0, 1 => 1 => 01
0, 1, 0 => 1 => 01
0, 1, 1 => 2 => 10
1, 0, 0 => 1 => 01
1, 0, 1 => 2 => 10
1, 1, 0 => 2 => 10
1, 1, 1 => 3 => 11

Comme vous le remarquez, S est "codé" sur deux bits. On note s1 le premier bit, s0 le deuxième bit. Réécrivons le tableau précédent :

a, b, c => s1, s0

0, 0, 0 => 0 => 0, 0
0, 0, 1 => 1 => 0, 1
0, 1, 0 => 1 => 0, 1
0, 1, 1 => 2 => 1, 0
1, 0, 0 => 1 => 0, 1
1, 0, 1 => 2 => 1, 0
1, 1, 0 => 2 => 1, 0
1, 1, 1 => 3 => 1, 1

Nous avons donc une table de vérité, avec des entrées (a, b, c) et des sorties (s1, s0). On peut donc, partant de cette table, créer un circuit logique additionnant trois bits :



Je vous épargne le détail de son contenu (un enchevêtrement de portes NON / OU / ET), mais vous pouvez vous *amuser* à  le retrouver.


Additionner deux nombres binaires

Souvenez-vous de la manière dont vous posiez des additions en CE1 (certes, je mentais en disant qu'il n'y avait aucun prérequis). En binaire, c'est rigoureusement la même chose.

Calculons par exemple la somme C des nombres binaires A et B. Pour simplifier, on prendra des nombres binaires à  quatre chiffre.

A est composé, de gauche à  droite, des chiffres a3, a2, a1, a0.
B est composé, de gauche à  droite, des chiffres b3, b2, b1, b0.
C est composé, de gauche à  droite, des chiffres c3, c2, c1, c0.

On additionne a0 et b0.
On obtient un nombre binaire à  deux chiffres (le S du paragraphe précédent).
On met le second dans c0, on retient le premier.

On additionne a1, b1 et la retenue précédente.
On obtient un nombre binaire à  deux chiffres.
On met le second dans c1, on retient le premier.

Et ainsi de suite.

Cela se résume par le circuit que voilà  :



On vient de concevoir un additionneur binaire. On peut imaginer d'autres circuits réalisant des opérations sur des nombres binaires : soustracteur, permutateur, inverseur...

La cellule mémoire



On peut faire deux opérations sur ce circuit : mise à  1 et mise à  0.


Mise à  1 (Set)

- On envoie de l'air comprimé dans Set. La sortie passe à  1.
- On relâche l'air comprimé dans Set. La sortie RESTE à  1.




Mise à  0 (Reset)

- On envoie de l'air comprimé dans Reset. La sortie passe à  0.
- On relâche l'air comprimé dans Reset. La sortie RESTE à  0.




Ce circuit est donc capable de mémoriser une information binaire (0 ou 1).



Sélectionner une cellule mémoire



Si l'entrée Sélection vaut 0, la cellule mémoire est coupée de l'extérieur.
Si l'entrée Sélection vaut 1, on peut accéder à  la cellule mémoire.

Cela permet de sélectionner une cellule mémoire particulière, pour écrire dedans (Set et Reset) ou pour lire son contenu (Sortie). Sur le schéma suivant, par exemple, c'est la cellule 3 qui est sélectionnée.





L'adressage

On veut maintenant concevoir le circuit suivant :

En entrée, on à  le numéro (en binaire) de l'espace mémoire que l'on veut sélectionner.
En sortie, on a de l'air comprimé dans le tuyau Sélection de l'espace mémoire que l'on veut sélectionner.

Voici un exemple pour 4 espaces mémoires (explications ci-dessous) :



Un bus est un ensemble de fils.

Si le bus d'adresse vaut 00 (a = 0 et b = 0), Sélection 1 vaudra 1 et les autres 0.
Si le bus d'adresse vaut 01 (a = 0 et b = 1), Sélection 2 vaudra 1 et les autres 0.
Si le bus d'adresse vaut 10 (a = 1 et b = 0), Sélection 3 vaudra 1 et les autres 0.
Si le bus d'adresse vaut 11 (a = 1 et b = 1), Sélection 4 vaudra 1 et les autres 0.

Avec un bus d'adresse de 2 fils, on peut donc sélectionner 4 espace mémoires.
Avec un bus d'adresse de 3 fils, on peut sélectionner 8 espace mémoires.
Avec un bus d'adresse de 4 fils, on peut sélectionner 16 espace mémoires.
...
Avec un bus d'adresse de 32 fils, on peut sélectionner 4 294 967 296 espaces mémoires. C'est, grosso modo, la mémoire vive des PC actuels.

En réalité, un espace mémoire ne contient pas une seule cellule mémoire, mais 32. C'est cela que l'on désigne lorsqu'on parle de "processeur 32 bits".
Pour lire et écrire dans un espace mémoire, on utilise donc pas un fil unique, mais un bus de 32 fils.
Accessoirement, on se débrouille pour utiliser le même bus pour lire et pour écrire. C'est le "bus de donnée".

On gère donc la mémoire d'un ordinateur avec un bus d'adresse et un bus de données.

L'horloge



Le cycle suivant se répète à  l'infini :

L'inhibiteur reçoit de l'air comprimé, il mord le tuyau.
L'air ne passe plus.
L'inhibiteur ne reçoit plus d'air comprimé, il se relâche.
L'air passe à  nouveau.

La sortie vaut donc 0, puis 1, puis 0, puis 1, puis 0, puis 1...
Ce phénomène est aussi régulier qu'un tic-tac d'horloge, d'où le nom du circuit.
Pour ralentir ce tic-tac, il suffit de rallonger le tuyau.


Le rafraîchisseur

C'est un "plug" que l'on installe devant une cellule mémoire :



Quand "ordre d'écriture" passe à  1, les inhibiteurs se relâche, et le contenu de "donnée" est écrit dans la cellule mémoire. En effet...
- Si "donnée" vaut 1, Set vaudra 1 et Reset vaudra 0 : la cellule est mise à  1.
- Si "donnée" vaut 0, Set vaudra 0 et Reset vaudra 1 : la cellule est mise à  0.

Cela permet de décider à  quel moment on "met a jour" la mémoire.

Symbole du rafraîchisseur :



On peut remplacer les fil par des bus :



Cela signifie juste que l'on rafraîchit chaque fil du bus.


Exemple : le compteur



A chaque fois que l'horloge passe à  1, "comptage" est remplacé dans l'espace mémoire par "comptage + 1". Ce circuit compte donc les tic-tac de l'horloge.

Fonctionnement général d'un ordinateur



A chaque fois que l'horloge passe à  1, les sorties du circuit logique sont écrites dans les espaces mémoires. Elle deviennent alors ses nouvelles entrées. Et ainsi de suite.

Dans ce schéma,
- Le circuit logique est appelé microprocesseur.
- Les espaces mémoires sont appelés registres.

Il y a tout au plus une dizaine de registres, parmi lesquels...
- Des registres quelconques : reg1, reg2, reg3...
- Des registres spéciaux : instruction et curseur. Leur fonction sera expliquée plus loin.


L'accès à  la mémoire vive

Ajoutons quelques éléments au microprocesseur, pour qu'il puisse accéder à  la mémoire vive du chapitre 3 :



Il possède à  présent de nouvelles entrées et sorties :

- Un bus "adresse", qui permet de sélectionner l'espace mémoire voulu.
- Un bus "lecture", qui délivre le contenu de l'espace mémoire sélectionné.
- Un bus "écriture", qui transporte les (éventuelles) nouvelles données à  écrire dans l'espace mémoire sélectionné.
- Un fil "ordre d'écriture", qui permet d'écrire le contenu du bus "écriture" dans l'espace mémoire sélectionné, par le biais d'un rafraîchisseur.

On peut donc manipuler à  souhait les milliards d'espaces de la mémoire vive... un par un. (Mais comme il y a quelques milliards de tic-tac d'horloge par seconde, ça compense.)


L'instruction

Le microprocesseur contient en fait plusieurs circuits logiques, chacun correspondant à  une fonction : additionner, soustraire, permuter, comparer...



Pour sélectionner la fonction voulue, on utilise un système d'adressage, comme au chapitre 3 :



Le bus d'instruction lit le contenu du registre instruction, qui contient le numéro de la fonction à  sélectionner... et peut lui-même être manipulé par le microprocesseur ! Commencez-vous à  comprendre l'oméga-power de la chose ?


Le programme

Un programme est une suite d'instructions élémentaires :

>> Faire ci
>> Faire ça
>> ...

A chaque instruction élémentaire correspond un circuit logique dans le microprocesseur. On peut donc écrire le programme en remplaçant les instructions par leur numéro :

>> 010110001
>> 101100101
>> ...

Où est est stocké ce programme ? Dans la mémoire vive, pardi. Voyons comment le microprocesseur s'y prend pour le lire.

Déjà , nous avons un registre spécial, nommé curseur, qui stocke l'adresse de la prochaine ligne de programme.

Ensuite, le microprocesseur contient un circuit logique "lecteur de programme". Il est sélectionné lorsque le registre instruction vaut 00000....0. Voici la fonction qu'il réalise :

- Il envoie le contenu du registre curseur dans le bus d'adresse.
- Il envoie le contenu du bus de lecture (la prochaine ligne de programme, donc) dans le registre instruction.
- Il additionne 1 au registre curseur.

(Pour les deux premiers points, il suffit de connecter des fils. Pour le dernier, on utilise l'additionneur binaire d'un chapitre 2.)

Ainsi, dès le prochain "top" (passage à  1 de l'horloge), on sélectionnera le circuit logique correspondant à  notre ligne de programme (à  présent stockée dans instruction).

Comme les autres circuit ne balancent rien dans le registre instruction (soit 00000...0), le circuit "lecteur de programme" sera à  nouveau sélectionné au "top" suivant. Sauf que, comme il a précédemment ajouté 1 au registre curseur, c'est la ligne de programme suivante qui sera lue.

Et ainsi de suite.


Exemple : programme multiplicateur

Voici un programme qui multiplie le contenu des registres "reg1" et "reg2", et stocke le résultat dans "reg3". On a donc : reg3 = reg1 x reg2 = reg1 + reg1 + reg1 + reg1.... "reg2" fois.

>> Mettre "reg3" à  0000...0
>> Additionner le contenu de "reg1" à  "reg3"
>> Soustraire 1 à  "reg2"
>> Si "reg2" vaut 000...0, additionner 1 à  "curseur"
>> Soustraire 4 à  "curseur"

Petite explication :


Bien sûr, on n'utilise pas cette méthode bourrine dans les ordinateurs, mais un algorithme similaire à  celui qu'on vous a enseigné à  l'école primaire.


En conclusion...

Tout les programmes que vous utilisez sur votre ordinateur, sont en fait une série d'instructions basiques. Bien sûr, ce "langage" de programmation (dit "langage machine") est atroce à  manipuler : les programmeurs utilisent donc des compilateurs, programmes qui convertissent un langage de programmation plus "humain" en langage machine. Compilateurs programmés eux-mêmes à  partir de compilateurs... mais il a bien fallu programmer le premier compilateur directement en langage machine, hé.

Un système d'exploitation (Windows, Linux...) est en fait un méta-programme : un programme qui gère l'ensemble de programmes ouverts simultanément. Ce méta-programme est exécuté à  l'allumage de l'ordinateur, il doit donc commencer à  l'adresse mémoire 00000...0 (car "curseur" est initialement à  zéro).

Donc, voilà . Des questions ? Le moindre point obscur ou douteux se doit d'être éclairci.

La souris

Les coordonnées x et y de la souris sont stockés dans des espaces mémoires réservés. On peut donc y accéder à  tout instant.


Le clavier



Quand une touche est pressée, deux des fils de sortie passent à  0 : on peut ainsi identifier cette touche.

Le numéro de la dernière touche pressée est stockée en mémoire. On a également un bit spécial (toujours en mémoire) qui vaut 1 à  l'instant où une touche est pressée, 0 sinon.


La mémoire morte

Le principe est le même que pour la mémoire vive, seul l'intérieur de cellules mémoire change :



Quand on envoie de l'air dans Set, le clapet est poussé à  droite.
Quand on envoie de l'air dans Reset, le clapet est poussé à  gauche.

Cela permet de mémoriser l'information lorsque l'ordinateur est éteint (plus d'alimentation en air comprimé), ce qui n'est pas le cas de la mémoire vive.

Pour pouvoir lire le contenu de la cellule, on relie le clapet à  un tiroir pneumatique :




L'écran

L'écran est un tableau de pixels. Un pixel est un ensemble de trois diodes lumineuses : une rouge, une verte, une bleue (R, V, B). En dosant l'intensité lumineuse dans chaque diode, on peut reconstituer n'importe quelle couleur.

Le contenu d'un pixel tient dans un espace mémoire de 24 bits :

- 8 bits codent l'intensité du rouge (de 0 à  255)
- 8 bits codent l'intensité du vert (de 0 à  255)
- 8 bits codent l'intensité du bleu (de 0 à  255)

Ce qui nous fait 255 x 255 x 255 = 16 581 375 couleurs.

A chaque pixel de l'écran correspond un espace mémoire. Comme on ne peut pas faire passer un million de pixels par un seul bus, on "repeint" l'écran pixel par pixel, très rapidement :



Sur le schéma ci-dessus, un pixel est sélectionné s'il est alimenté horizontalement et verticalement. Un double-système d'adressage permet de faire correspondre une adresse à  un pixel. Il suffit donc de parcourir toutes les adresses (avec un compteur, par exemple) tout en envoyant les informations correspondantes dans le bus de données.


Le son

Le son est produit par la vibration acoustique d'une membrane. Un espace mémoire correspond, à  chaque instant, à  la valeur de la position de cette membrane. Il faut ensuite convertir ce nombre binaire en position réelle :



En effet :
- Le bit a0 vaut 1 en décimal
- Le bit a1 vaut 2 en décimal
- Le bit a2 vaut 4 en décimal
- Le bit a3 vaut 8 en décimal
- etc...