Petit essai de vulgarisation au terme duquel vous pourrez vous exclamer, le visage déformé par l'émotion : [i:qt1chbsv]&quot;Oh, put... ! C'est donc ainsi qu'un ordinateur fonctionne !&quot;[/i:qt1chbsv]

[u:qt1chbsv]Aucune[/u:qt1chbsv] notion scientifique n'est requise. Je me suis efforcé de rendre cet exposé le plus simple d'abord possible.

Outre la nature philantrope de cette entreprise, c'est également l'occasion de mesurer ma capacité à  inculquer de scientifiques notions dans des esprits vierges. J'attends donc quelques retours.

Si tout n'est pas limpide dès la première lecture, si le moindre point vous fait lever le sourcil d'incompréhension (ou vous taper la tête contre les murs en hurlant), vous êtes vivement invité à  le signaler sur ce sujet. Si vous interrompez votre lecture, indiquez au moins LE point qui vous a fait abandonner (l'alinéa b du paragraphe 42, par exemple). [i:qt1chbsv]D'avance merci.[/i:qt1chbsv]

Voici le plan général :

Chapitre 1 - Les circuits logiques
Chapitre 2 - Les opérations binaires
Chapitre 3 - La mémoire
Chapitre 4 - Le microprocesseur

[color=#8000BF:qt1chbsv]Je précise, avant de me faire lyncher par les deux ou trois scientifiques du forum, que tout ceci n'est *bien entendu* qu'une version très simplifiée de ce qui se passe en réalité. L'objectif est avant tout de faire passer le concept. Toutefois, si vous tenez à  étaler votre science, vous êtes les bienvenus.[/color:qt1chbsv]





[size=200:qt1chbsv][b:qt1chbsv]Chapitre 1 - Les circuits logiques[/b:qt1chbsv][/size:qt1chbsv]

[spoiler:qt1chbsv][size=150:qt1chbsv][b:qt1chbsv]Les composants de base[/b:qt1chbsv][/size:qt1chbsv]

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


[u:qt1chbsv][b:qt1chbsv]Les tuyaux[/b:qt1chbsv][/u:qt1chbsv]

Un tuyau vide sera noté &quot;0&quot;.
Un tuyau rempli d&#39;air comprimé sera noté &quot;1&quot;.

[img:qt1chbsv]http&#58;//unclerosiel&#46;free&#46;fr/Chapitre%201/Chapitre%201/01&#46;png[/img:qt1chbsv]


[u:qt1chbsv][b:qt1chbsv]Les sources d&#39;air comprimé[/b:qt1chbsv][/u:qt1chbsv]

Tout tuyau au contact d&#39;une source se voit rempli d&#39;air comprimé.

[img:qt1chbsv]http&#58;//unclerosiel&#46;free&#46;fr/Chapitre%201/Chapitre%201/02&#46;png[/img:qt1chbsv]


[u:qt1chbsv][b:qt1chbsv]Les inhibiteurs[/b:qt1chbsv][/u:qt1chbsv]

Si l&#39;on envoie de l&#39;air comprimé dans l&#39;inhibiteur, il bloquera la circulation dans le tuyau.

[img:qt1chbsv]http&#58;//unclerosiel&#46;free&#46;fr/Chapitre%201/Chapitre%201/03&#46;png[/img:qt1chbsv]


[u:qt1chbsv][b:qt1chbsv]Exemple de circuit simplissime :[/b:qt1chbsv][/u:qt1chbsv] le circuit inverseur.

Si l&#39;entrée vaut 1, la sortie vaut 0.
Si l&#39;entrée vaut 0, la sortie vaut 1.

[img:qt1chbsv]http&#58;//unclerosiel&#46;free&#46;fr/Chapitre%201/Chapitre%201/04&#46;png[/img:qt1chbsv]



[size=150:qt1chbsv][b:qt1chbsv]La porte NAND[/b:qt1chbsv][/size:qt1chbsv]

Une porte logique est un circuit possédant des tuyaux d&#39;entrée et des tuyaux de sortie. L&#39;état des sorties &#40;0 ou 1&#41; dépend de l&#39;état des entrées &#40;0 ou 1&#41;.

Observons par exemple la porte &quot;NAND&quot;. Nous avons deux entrées &#40;a et b&#41; et une sortie &#40;s&#41;.

[img:qt1chbsv]http&#58;//unclerosiel&#46;free&#46;fr/Chapitre%201/Chapitre%201/05&#46;png[/img:qt1chbsv]

Envisageons tous les cas possibles en entrée :


[u:qt1chbsv][b:qt1chbsv]a = 0 et b = 0 :[/b:qt1chbsv][/u:qt1chbsv]

On a alors s = 1.

[img:qt1chbsv]http&#58;//unclerosiel&#46;free&#46;fr/Chapitre%201/Chapitre%201/06&#46;png[/img:qt1chbsv]


[u:qt1chbsv][b:qt1chbsv]a = 0 et b = 1 :[/b:qt1chbsv][/u:qt1chbsv]

On a alors s = 1.

[img:qt1chbsv]http&#58;//unclerosiel&#46;free&#46;fr/Chapitre%201/Chapitre%201/07&#46;png[/img:qt1chbsv]


[b:qt1chbsv][u:qt1chbsv]a = 1 et b = 0 :[/u:qt1chbsv][/b:qt1chbsv]

On a alors s = 1.

[img:qt1chbsv]http&#58;//unclerosiel&#46;free&#46;fr/Chapitre%201/Chapitre%201/08&#46;png[/img:qt1chbsv]


[u:qt1chbsv][b:qt1chbsv]a = 1 et b = 1 :[/b:qt1chbsv][/u:qt1chbsv]

On a alors s = 0.

[img:qt1chbsv]http&#58;//unclerosiel&#46;free&#46;fr/Chapitre%201/Chapitre%201/09&#46;png[/img:qt1chbsv]


On résume ceci dans un tableau :

[img:qt1chbsv]http&#58;//img222&#46;imageshack&#46;us/img222/9704/10aw6&#46;png[/img:qt1chbsv]

Ce tableau se nomme [u:qt1chbsv]table de vérité[/u:qt1chbsv]. Il suffit à  décrire le fonctionnement la porte NAND. On peut donc la schématiser par une &quot;boîte noire&quot; :

[img:qt1chbsv]http&#58;//unclerosiel&#46;free&#46;fr/Chapitre%201/Chapitre%201/11&#46;png[/img:qt1chbsv]



[size=150:qt1chbsv][b:qt1chbsv]Les autres portes logiques[/b:qt1chbsv][/size:qt1chbsv]


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

&#40;Pour chacune, de gauche à  droite : sa représentation &quot;boîte noire&quot; // sa constitution interne // sa table de vérité&#41;


[u:qt1chbsv][b:qt1chbsv]La porte NON :[/b:qt1chbsv][/u:qt1chbsv]

C&#39;est le circuit inverseur vu plus haut.

[img:qt1chbsv]http&#58;//img128&#46;imageshack&#46;us/img128/1086/12ai8&#46;png[/img:qt1chbsv]


[b:qt1chbsv][u:qt1chbsv]La porte ET :[/u:qt1chbsv][/b:qt1chbsv]

s vaut 1 si a [u:qt1chbsv]et[/u:qt1chbsv] b valent 1.

[img:qt1chbsv]http&#58;//unclerosiel&#46;free&#46;fr/Chapitre%201/Chapitre%201/13&#46;png[/img:qt1chbsv]


[u:qt1chbsv][b:qt1chbsv]La porte OU :[/b:qt1chbsv][/u:qt1chbsv]

s vaut 1 si a [u:qt1chbsv]ou[/u:qt1chbsv] b vaut 1 &#40;ou les deux&#41;.

[img:qt1chbsv]http&#58;//unclerosiel&#46;free&#46;fr/Chapitre%201/Chapitre%201/14&#46;png[/img:qt1chbsv]


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



[size=150:qt1chbsv][b:qt1chbsv]Exemple de circuit logique[/b:qt1chbsv][/size:qt1chbsv]

En assemblant les diverses portes ci-dessus, on peut modéliser n&#39;importe quel comportement, pourvu qu&#39;il soit [u:qt1chbsv]systématique[/u:qt1chbsv]. Prenons par exemple le fonctionnement de Raphaël &quot;Raphaël Lafarge&quot; Lafarge :

[i:qt1chbsv]&quot;Je sors de chez moi si j&#39;ai un rencart, OU s&#39;il y a un film intéressant au cinéma ET que je n&#39;ai PAS de chapitre de Mirinar à  écrire.&quot;[/i:qt1chbsv]

En entrée, nous avons les affirmations suivantes :

[i:qt1chbsv]&quot;J&#39;ai un rencart&quot;
&quot;Il y a un film intéressant au cinéma&quot;
&quot;J&#39;ai un chapitre de Mirinar à  écrire&quot;[/i:qt1chbsv]

En sortie, nous avons l&#39;affirmation suivante :

[i:qt1chbsv]&quot;Je sors de chez moi&quot;[/i:qt1chbsv]

Ces affirmation seront notées &quot;1&quot; &#40;air comprimé&#41; si elles sont vraies, et &quot;0&quot; &#40;pas d&#39;air comprimé&#41; si elles sont fausses.

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

[img:qt1chbsv]http&#58;//unclerosiel&#46;free&#46;fr/Chapitre%201/Chapitre%201/15&#46;png[/img:qt1chbsv]

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

Et maintenant, vos appréciations et remarques, messieurs.[/spoiler:qt1chbsv]


[size=200:qt1chbsv][b:qt1chbsv]Chapitre 2 - Les opérations binaires[/b:qt1chbsv][/size:qt1chbsv]


[spoiler:qt1chbsv][size=150:qt1chbsv][b:qt1chbsv]Le binaire[/b:qt1chbsv][/size:qt1chbsv]

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

[b:qt1chbsv]Nombre binaire =&gt; Nombre décimal correspondant[/b:qt1chbsv]

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


[size=150:qt1chbsv][b:qt1chbsv]Additionner trois bits[/b:qt1chbsv][/size:qt1chbsv]

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 &#40;notée S&#41; est le nombre de &quot;1&quot; que l&#39;on compte parmis a, b, et c. Traduisons cela par un tableau qui recense tous les cas :

[b:qt1chbsv]A, B, C =&gt; S &#40;en décimal&#41; =&gt; S &#40;en binaire&#41;[/b:qt1chbsv]

0, 0, 0 =&gt; 0 =&gt; 00
0, 0, 1 =&gt; 1 =&gt; 01
0, 1, 0 =&gt; 1 =&gt; 01
0, 1, 1 =&gt; 2 =&gt; 10
1, 0, 0 =&gt; 1 =&gt; 01
1, 0, 1 =&gt; 2 =&gt; 10
1, 1, 0 =&gt; 2 =&gt; 10
1, 1, 1 =&gt; 3 =&gt; 11

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

[b:qt1chbsv]a, b, c =&gt; s1, s0[/b:qt1chbsv]

0, 0, 0 =&gt; 0 =&gt; 0, 0
0, 0, 1 =&gt; 1 =&gt; 0, 1
0, 1, 0 =&gt; 1 =&gt; 0, 1
0, 1, 1 =&gt; 2 =&gt; 1, 0
1, 0, 0 =&gt; 1 =&gt; 0, 1
1, 0, 1 =&gt; 2 =&gt; 1, 0
1, 1, 0 =&gt; 2 =&gt; 1, 0
1, 1, 1 =&gt; 3 =&gt; 1, 1

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

[img:qt1chbsv]http&#58;//img266&#46;imageshack&#46;us/img266/1249/88349861xt5&#46;jpg[/img:qt1chbsv]

Je vous épargne le détail de son contenu &#40;un enchevêtrement de portes NON / OU / ET&#41;, mais vous pouvez vous *amuser* à  le retrouver.


[size=150:qt1chbsv][b:qt1chbsv]Additionner deux nombres binaires[/b:qt1chbsv][/size:qt1chbsv]

Souvenez-vous de la manière dont vous posiez des additions en CE1 &#40;certes, je mentais en disant qu&#39;il n&#39;y avait aucun prérequis&#41;. En binaire, c&#39;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 &#40;le S du paragraphe précédent&#41;.
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à  :

[img:qt1chbsv]http&#58;//img510&#46;imageshack&#46;us/img510/9759/30719096fs7&#46;jpg[/img:qt1chbsv]

On vient de concevoir un additionneur binaire. On peut imaginer d&#39;autres circuits réalisant des opérations sur des nombres binaires : soustracteur, permutateur, inverseur...[/spoiler:qt1chbsv]