Feuille de route de la logique numérique : des portes au CPU en 30 jours

En bref : trente jours, quatre semaines, un parcours structuré depuis votre première porte AND jusqu’à un CPU fonctionnel que vous aurez câblé vous-même. Chaque jour associe un article (la théorie) à un modèle de simulateur interactif (la pratique). Consacrez-y une heure par jour. Au jour 30, vous saurez comment fonctionnent les ordinateurs — non comme une métaphore, mais comme un circuit que vous pouvez parcourir cycle d’horloge après cycle d’horloge.

La logique numérique devient plus difficile lorsque l’algèbre et les circuits sont enseignés séparément. L’algèbre sans circuit peut sembler désincarnée ; un schéma de CPU sans aisance au niveau des portes peut se réduire à recopier des fils. Cette feuille de route maintient les deux points de vue ensemble : chaque expression booléenne possède un circuit et chaque circuit a une raison d’être.

Le plan organise 30 séances d’étude en quatre semaines thématiques, en associant une lecture ciblée à un exercice de simulation. Considérez l’heure quotidienne comme un rythme conseillé, pas comme une promesse : répétez une séance si vous ne pouvez pas encore prédire le comportement du circuit avant de le lancer.

Vous pouvez l’utiliser comme plan d’autoformation, programme d’un cours universitaire de 4 crédits, guide de préparation à un entretien matériel ou index de référence lorsqu’un sujet précis se présente au travail. Ajoutez la page à vos favoris, suivez le parcours, et le domaine de la logique numérique cessera de sembler intimidant.

À qui s’adresse cette feuille de route ?

Si vous êtes étudiant en informatique et qu’on vous a dit que le matériel n’était que « des couches d’abstraction », mais que vous voulez voir la couche la plus basse, ce parcours est pour vous. Si vous êtes ingénieur logiciel et travaillez sur des systèmes bas niveau — embarqué, noyaux, compilateurs, performances — avec un modèle mental flou de ce qui se trouve réellement dans le silicium, ce parcours est pour vous. Si vous êtes passionné et avez regardé mille vidéos « comment fonctionne un CPU » en voulant réellement en construire un, ce parcours est aussi pour vous.

Les seuls prérequis sont une connaissance pratique des nombres binaires (nous les réviserons en semaine 1), des notions d’algèbre et la patience de consacrer environ une heure par jour pendant quatre semaines. Vous aurez besoin d’un navigateur, c’est tout. Chaque modèle renvoie à DigiSim.io, qui fonctionne dans le navigateur sans installation.

Comment la feuille de route est structurée

Semaine 1   Jours  1- 7   Portes et bases booléennes
Semaine 2   Jours  8-14   Circuits combinatoires
Semaine 3   Jours 15-21   Logique séquentielle
Semaine 4   Jours 22-28   Arithmétique et mémoire
Final       Jours 29-30   Assemblage en CPU

Chaque jour suit le même format :

• Objectif — une ou deux phrases nommant la compétence que vous aurez acquise en fin de journée ;
• Lire — un article précis qui enseigne la théorie ;
• Construire — un modèle de simulateur précis qui fournit une pratique concrète.

Prévoyez environ 20 minutes de lecture et 40 minutes de construction. C’est la construction qui consolide l’apprentissage. Sauter cette étape est la raison la plus fréquente pour laquelle les autodidactes ne retiennent pas la logique numérique.

Semaine 1 — Portes et fondements booléens

Impossible de comprendre un CPU sans comprendre d’abord ses plus petites briques. La semaine 1 développe l’aisance au niveau des portes : chaque primitive booléenne, les tables de vérité, les symboles et leur composition en expressions. Le dimanche, vous devriez pouvoir regarder une expression booléenne et prédire le circuit, puis regarder un circuit et prédire sa table de vérité.

Jour 1 — Bienvenue dans la logique numérique

Objectif : comprendre ce qu’est un signal numérique et ce que fait une porte logique au niveau physique.

Lire : Logique numérique 101 : vos premiers pas avec les portes AND, OR et NOT

Construire : Démonstration interrupteur et lampe — basculez un interrupteur, une lampe s’allume. C’est le plus petit circuit numérique possible et le point de départ de la lignée de tout microprocesseur.

Jour 2 — La porte AND

Objectif : assimiler la table de vérité AND et reconnaître les endroits où apparaît une logique de type AND.

Lire : La porte AND : fondement de la logique numérique et de la prise de décision

Construire : Système de sécurité à porte AND — une porte qui ne s’ouvre que si deux conditions sont réunies. Explorez ensuite la référence du composant AND.

Jour 3 — Les portes OR et NOT

Objectif : compléter le trio des opérateurs booléens universels et voir comment OR et NOT se composent avec AND.

Lire : La porte OR : comprendre le vote démocratique de la logique numérique, puis L’humble porte NOT.

Construire : Système d’alarme à porte OR — une alarme qui se déclenche si un capteur quelconque réagit. Les primitives OR et NOT sont vos références de composants du jour.

Jour 4 — La famille exclusive : XOR et XNOR

Objectif : comprendre la différence entre OR et XOR et pourquoi la logique exclusive intervient dans les tests d’égalité et l’addition.

Lire : La porte XOR : maîtriser la logique de la différence, puis La porte XNOR : championne de l’égalité. Complétez avec XOR contre XNOR : la différence critique dans la détection d’erreurs pour la motivation pratique.

Construire : explorez la référence du composant XOR et celle du composant XNOR. Reliez deux interrupteurs à un XOR et observez la sortie.

Jour 5 — NAND et NOR : les portes universelles

Objectif : comprendre pourquoi NAND seule (ou NOR seule) est fonctionnellement complète et ce que cela implique pour la fabrication des puces.

Lire : La porte NAND : la brique unique de toute la logique numérique, puis Le héros méconnu : comment la porte NOR a construit Apollo.

Construire : construisez une porte AND avec des portes NAND uniquement. Les primitives NAND et NOR sont vos références. Consultez ensuite la référence des tables de vérité des portes logiques et vérifiez votre construction.

Jour 6 — Algèbre de Boole et lois de De Morgan

Objectif : manipuler algébriquement les expressions booléennes et utiliser les lois de De Morgan pour simplifier les circuits.

Lire : Maîtriser l’algèbre de Boole : le fondement de la conception des circuits numériques, puis Maîtriser les lois de De Morgan.

Construire : prenez une expression à 3 variables comme $F = A \cdot B + \overline{A} \cdot C$, dessinez le circuit, puis transformez-le avec De Morgan et vérifiez que les deux circuits produisent la même sortie. La référence du composant buffer et notre article sur la raison d’être des buffers bouclent la boucle au niveau des portes.

Jour 7 — Symboles, portes à plusieurs entrées et histoire du binaire

Objectif : lire des schémas de circuits en notation ANSI et IEC, manier les portes à plusieurs entrées avec aisance et comprendre les origines du binaire.

Lire : Décoder la logique numérique : symboles ANSI et IEC, puis Au-delà de deux entrées : maîtriser les portes logiques à entrées multiples. Terminez la semaine par l’escapade passionnante Le voyage de 3 500 ans du binaire.

Construire : dessinez la même fonction à 4 entrées dans les notations ANSI et IEC dans votre simulateur. Assurez-vous de pouvoir passer aisément de l’une à l’autre.

Semaine 2 — Circuits combinatoires

La semaine 2 vous fait passer des portes individuelles aux circuits complets dont les sorties sont des fonctions pures des entrées. Le dimanche, vous devriez savoir prendre une expression booléenne, la simplifier avec une carte de Karnaugh et réaliser une implémentation combinatoire rapide avec les bonnes primitives — multiplexeurs, décodeurs, encodeurs et buffers.

Jour 8 — Somme de produits

Objectif : convertir toute table de vérité en expression somme de produits et en circuit AND-OR.

Lire : Maîtriser la somme de produits (SOP).

Construire : choisissez une fonction à 3 variables et implémentez-la sous forme SOP. Comparez le nombre de portes à la forme canonique (non simplifiée).

Jour 9 — Produit de sommes et formes duales

Objectif : comprendre la représentation duale, savoir quand POS est préférable à SOP et apprendre à passer de l’une à l’autre.

Lire : Au-delà de la somme de produits : maîtriser le produit de sommes.

Construire : réimplémentez la fonction d’hier sous forme POS et vérifiez que la table de vérité est identique. Notez la différence de nombre de portes.

Jour 10 — Cartes de Karnaugh

Objectif : utiliser une carte de Karnaugh pour trouver les implémentations SOP et POS minimales d’une fonction à 4 variables.

Lire : Visualiser la logique : maîtriser les cartes de Karnaugh.

Construire : prenez la fonction $F(A,B,C,D) = \sum m(0,1,2,5,6,7,8,9,10,14)$, dessinez sa carte de Karnaugh et trouvez la couverture minimale. Construisez-la ensuite.

Jour 11 — Conditions don’t-care

Objectif : utiliser les don’t-care pour trouver des circuits minimaux pour les entrées qui vous intéressent.

Lire : Les conditions don’t-care dans les cartes de Karnaugh.

Construire : ajoutez trois don’t-care à la fonction du jour 10 et minimisez-la à nouveau. Le nombre de portes diminue généralement de façon visible.

Jour 12 — Multiplexeurs et démultiplexeurs

Objectif : comprendre le multiplexeur comme routeur de fils programmable et le démultiplexeur comme son inverse.

Lire : Les multiplexeurs (MUX) démystifiés, puis Tutoriel du démultiplexeur : 1 vers 4 et 1 vers 8.

Construire : utilisez un multiplexeur 4 vers 1 pour implémenter une fonction arbitraire à 2 variables (le multiplexeur est un bloc combinatoire universel). Références des composants : MULTIPLEXER, DEMULTIPLEXER.

Jour 13 — Décodeurs, encodeurs et encodeurs prioritaires

Objectif : construire un pilote d’afficheur 7 segments et comprendre le codage prioritaire pour les contrôleurs d’interruptions.

Lire : Décodeurs et encodeurs : piloter un afficheur 7 segments, puis L’encodeur prioritaire expliqué et Décodeur BCD vers 7 segments.

Construire : câblez un décodeur BCD vers 7 segments pour afficher les chiffres de 0 à 9. Références des composants : DECODER, ENCODER.

Jour 14 — Buffers trois états et arbitrage de bus

Objectif : comprendre le troisième état — la haute impédance — et comment les bus partagés sont physiquement possibles.

Lire : Le héros méconnu : pourquoi les buffers numériques sont indispensables, puis Buffers trois états et arbitrage de bus.

Construire : câblez deux registres sur un bus partagé de 4 bits avec des buffers trois états. Le composant TRI_STATE_BUFFER est votre référence. Bonus : lisez l’article sur les aléas de la logique combinatoire pour comprendre les pièges temporels.

Semaine 3 — Logique séquentielle

Les circuits combinatoires n’ont pas de mémoire. Les vrais ordinateurs en ont. La semaine 3 présente les éléments de stockage — verrous, bascules, registres, compteurs, registres à décalage — ainsi que la discipline temporelle qui les maintient fiables.

Jour 15 — Le verrou SR

Objectif : comprendre la bistabilité et pourquoi un verrou peut conserver une valeur indéfiniment.

Lire : Le verrou SR : décomposer la brique fondamentale.

Construire : Démonstration du verrou SR. Parcourez chaque combinaison d’entrée et observez l’état interdit. La primitive SR_LATCH est la référence du composant.

Jour 16 — Le verrou D

Objectif : ajouter une entrée de données et une validation au verrou SR pour obtenir la mémoire sensible au niveau la plus simple.

Lire : Maîtriser la logique séquentielle : le verrou D expliqué.

Construire : Verrou D de base. Observez la fenêtre de transparence : lorsque la validation est HIGH, la sortie suit l’entrée ; lorsqu’elle passe à LOW, la valeur est conservée.

Jour 17 — La bascule D

Objectif : comprendre la différence entre stockage sensible au niveau et stockage déclenché sur front, et pourquoi tous les registres modernes utilisent ce dernier.

Lire : La bascule D : le héros méconnu du numérique synchrone.

Construire : Bascule D déclenchée sur front. Comparez son diagramme temporel à celui du verrou D d’hier. La primitive D_FLIP_FLOP est la référence.

Jour 18 — Bascules JK et T

Objectif : compléter la famille des bascules et comprendre pourquoi chaque variante existe.

Lire : Bascules SR contre JK : les bases de la logique séquentielle, puis La bascule JK : maîtriser la brique universelle, puis La bascule T : le héros méconnu du comptage numérique.

Construire : Bascule JK maître-esclave. Les primitives JK_FLIP_FLOP et T_FLIP_FLOP sont vos références.

Jour 19 — L’horloge et la discipline temporelle

Objectif : comprendre le temps de setup, le temps de hold, le délai de propagation et la métastabilité — la physique analogique dont dépend la conception synchrone.

Lire : L’impulsion d’horloge : pourquoi les ordinateurs ont besoin d’un battement, puis L’horloge invisible : maîtriser setup, hold et métastabilité, puis Délai de propagation : la physique qui dicte la vitesse numérique et Le skew d’horloge.

Construire : pilotez une bascule avec le composant horloge. Rapprochez progressivement une transition de données d’un front d’échantillonnage et comparez la valeur capturée par le modèle numérique. Calculez ensuite pourquoi le franchissement physique équivalent peut devenir métastable. Un simulateur logique ne reproduit ni la tension analogique ni le temps de résolution statistique d’un nœud réellement métastable.

Jour 20 — Registres et registres à décalage

Objectif : combiner des bascules en stockage multibit et apprendre les quatre modes de registres à décalage.

Lire : Maîtriser les registres à décalage : du série-parallèle, puis Modes SISO, SIPO, PISO et PIPO des registres à décalage. Reliez les registres à chargement parallèle à la référence du registre 8 bits.

Construire : Registre 4 bits avec horloge et démonstration d’un registre à décalage. Références des composants : REGISTER, SHIFT_REGISTER.

Jour 21 — Compteurs et machines à états

Objectif : construire des compteurs de différents modules et comprendre la distinction Mealy–Moore pour les machines à états.

Lire : Compteurs et machines à états : piloter les séquences numériques, puis Maîtriser la division de fréquence : des bascules au modulo-N, puis Le compteur de Johnson : maîtriser l’anneau torsadé, et enfin Machines à états Mealy contre Moore pour la théorie des FSM.

Construire : Compteur binaire 4 bits, puis compteur ripple asynchrone 4 bits. Comparez leur timing. Le composant COUNTER est la référence.

Semaine 4 — Arithmétique et mémoire

La semaine 4 vous conduit au seuil d’un vrai CPU. Vous construirez des additionneurs, des comparateurs, une ALU et les primitives mémoire qui stockent données et instructions. Le dimanche, vous disposerez de tous les composants nécessaires à un CPU.

Jour 22 — Demi-additionneur et additionneur complet

Objectif : construire le plus petit circuit arithmétique et le chaîner pour obtenir un additionneur multibit.

Lire : Le demi-additionneur : votre premier pas dans la conception de logique numérique, puis Le demi-additionneur contre l’additionneur complet.

Construire : Démonstration du composant demi-additionneur, puis demi-additionneur 1 bit, puis additionneur complet avec retenue. Références : HALF_ADDER, FULL_ADDER.

Jour 23 — Additionneurs à propagation de retenue et à anticipation de retenue

Objectif : comprendre pourquoi la propagation de retenue est lente à grande échelle et comment l’anticipation de retenue justifie son coût en silicium.

Lire : Maîtriser l’addition binaire : construire un additionneur à propagation de retenue 4 bits, puis Additionneur à anticipation de retenue : plus rapide que la propagation.

Construire : câblez quatre additionneurs complets en additionneur à propagation de retenue 4 bits. Mesurez la propagation dans le pire cas. Les composants ADDER et ADDER_8BIT sont vos références.

Jour 24 — Complément à deux et arithmétique signée

Objectif : comprendre comment effectuer une soustraction avec une addition et comment calculer les indicateurs de signe et de débordement.

Lire : Le complément à deux expliqué : arithmétique binaire signée.

Construire : modifiez l’additionneur du jour 23 pour gérer la soustraction en inversant le second opérande et en fixant la retenue d’entrée à 1. Vérifiez qu’il produit le bon résultat en complément à deux pour les nombres négatifs.

Jour 25 — Comparateurs

Objectif : construire des comparateurs d’égalité et de magnitude et comprendre leur place dans un CPU.

Lire : Comparateur numérique expliqué : égalité et magnitude.

Construire : câblez un comparateur d’égalité 4 bits avec des XNOR et un arbre AND. La primitive COMPARATOR est la référence.

Jour 26 — L’ALU

Objectif : combiner un additionneur, un comparateur et un bloc logique derrière un multiplexeur pour construire une unité arithmétique programmable.

Lire : Comment fonctionne une ALU : l’unité arithmétique et logique à partir de portes.

Construire : Démonstration d’une ALU 4 bits, puis passez au système ALU 8 bits. Références : ALU, ALU_8BIT.

Jour 27 — Les indicateurs

Objectif : calculer les indicateurs Zéro, Retenue, Signe et Débordement à partir de la sortie de l’ALU et les stocker.

Lire : Registre d’indicateurs CPU : retenue, zéro, débordement, signe.

Construire : Modèle de registre d’indicateurs CPU. La primitive FLAGS_REGISTER est la référence.

Jour 28 — Mémoire : RAM et ROM

Objectif : construire une mémoire adressable et comprendre la différence entre RAM volatile et ROM non volatile.

Lire : RAM contre ROM : la différence essentielle, avec circuits.

Construire : Système mémoire RAM de base et RAM avec contrôle d’adresse. Références des composants : RAM, ROM. Bonus : l’article sur l’endianness pour comprendre la disposition des valeurs multioctets.

Jours 29–30 — Construire un CPU complet

Vous avez maintenant tous les composants nécessaires à un CPU de base. Les deux derniers jours sont ceux où ils se réunissent.

Jour 29 — Le cycle fetch–decode–execute

Objectif : suivre une instruction depuis la mémoire jusqu’à l’exécution et l’écriture de retour, micro-opération par micro-opération.

Lire : Visualiser le cycle fetch–decode–execute, puis l’article plus long Comment fonctionne un microprocesseur : analyse fetch–decode–execute. Pour les éléments mobiles : Compteur ordinal, registre d’instruction et étape de décodage.

Construire : Modèle de séquenceur d’instructions. Faites une pause entre les cycles et observez chaque transfert de registre. Références des composants : PROGRAM_COUNTER_8BIT, INSTRUCTION_REGISTER, CONTROL_UNIT, ACCUMULATOR.

Jour 30 — Construire votre propre CPU

Objectif : relier les composants de la semaine 4 au compteur ordinal, au registre d’instruction et à l’unité de contrôle du jour 29 pour obtenir un CPU fonctionnel et programmable.

Lire : Construire un CPU de zéro dans un simulateur.

Construire : partez du modèle de séquenceur d’instructions et modifiez-le. Ajoutez une instruction. Regardez-la s’exécuter. La première fois que vous écrirez un programme dans votre propre langage assembleur et verrez votre CPU l’exécuter, toute la feuille de route prendra son sens.

Après 30 jours — Où aller ensuite

Trente jours vous mèneront à un CPU fonctionnel. Plusieurs directions s’ouvrent ensuite.

Approfondir l’architecture

Une fois le cycle de base devenu intuitif, la couche suivante est celle qui rend les CPU modernes rapides : pipeline, caches, prédiction de branchement, exécution dans le désordre. Notre analyse approfondie des microprocesseurs fait le pont vers ces sujets.

Davantage d’arithmétique

La multiplication et la virgule flottante constituent des mondes à part. Lisez le multiplicateur de Booth et la virgule flottante IEEE 754 pour les deux couches suivantes.

Détection et correction d’erreurs

Les systèmes réels perdent des bits. Parité, codes de Hamming et sommes de contrôle leur permettent de résister. Lisez le tutoriel du bit de parité et Correction d’erreurs par code de Hamming.

Encodages spécialisés

Le code Gray et le BCD apparaissent là où le binaire ordinaire atteint ses limites. Lisez Le code Gray expliqué et Fondamentaux du BCD.

Outils et méthodologie

Une fois que vous simulez de vrais circuits, les outils de débogage comptent. Lisez Utiliser l’oscilloscope pour déboguer les circuits numériques et explorez la référence du composant oscilloscope.

Écrire des leçons

Si vous voulez enseigner ce que vous avez appris, consultez Intégrer un circuit interactif dans une leçon ou un article et Leçons SimCast : tutoriels de circuits pas à pas.

Choisir ses outils

Si vous décidez à quel simulateur vous consacrer, notre comparaison des meilleurs simulateurs de logique numérique en 2026 et la fin du breadboard défendent la simulation dans le navigateur comme élément durable de la boîte à outils d’apprentissage. Nouveau sur DigiSim ? Vos cinq premières minutes avec DigiSim.io est le point d’entrée le plus accueillant.

Conseils pour suivre la feuille de route

Quelques habitudes distinguent les étudiants qui terminent de ceux qui restent bloqués.

• Notez ce que vous apprenez chaque jour. Deux phrases dans un carnet valent mieux que d’essayer de tout retenir. Les concepts s’empilent ; vous devez pouvoir retrouver le jour 12 lorsque le jour 23 parle de multiplexeurs.
• Construisez le circuit avant de lire l’article. C’est contre-intuitif, mais cela fonctionne. Parcourez l’objectif, essayez de câbler le circuit, puis lisez l’article. Il aura davantage d’impact parce que vous aurez déjà échoué aux bons endroits.
• En cas de blocage, lisez la table de vérité. Presque toute confusion de logique numérique se résout par une ligne de table de vérité. Notre référence des tables de vérité des portes logiques est l’index.
• Avancez à chaque cycle d’horloge. En particulier à partir de la semaine 3. La tentation de laisser le simulateur fonctionner en continu est forte ; résistez-y. Les circuits séquentiels ne prennent sens qu’un cycle à la fois.
• Relisez le jour précédent avant de commencer le suivant. Trois minutes de révision produisent un effet cumulatif.
• Ne sautez aucun jour. Si la vie vous en empêche, faites une journée moitié moins longue, mais faites quelque chose. Une pause de deux semaines effacera une semaine d’élan.

Un calendrier de lecture à imprimer

Si vous souhaitez voir tout le programme d’un coup d’œil :

Ce qui devient difficile et comment persévérer

Une feuille de route de 30 jours qui prétend que rien n’est difficile serait malhonnête. Certains jours sont fluides : vous lisez, vous câblez, vous comprenez. D’autres sont des falaises. Savoir lesquels vous permet de répartir votre énergie.

Les falaises où nous avons vu des étudiants tomber :

• Jour 6 (algèbre de Boole). L’algèbre sur des symboles semble déconnectée des portes sur des fils. La solution est de toujours dessiner le circuit à côté de l’algèbre. Lorsque vous appliquez une transformation de De Morgan, redessinez le circuit. C’est le retour visuel qui fixe l’abstraction.
• Jour 10 (cartes de Karnaugh). Les cartes de Karnaugh ressemblent à un sudoku. Ce n’en est pas un : c’est un dépliage en 2D de la table de vérité où les cellules voisines diffèrent d’une seule variable. Convainquez-vous-en en étiquetant lignes et colonnes dans l’ordre du code Gray ; le reste de la technique en découlera.
• Jour 17 (bascule D). Le passage du sensible au niveau au déclenché sur front. La plupart des étudiants le sous-estiment parce que le symbole est presque identique. Le changement conceptuel est immense : une bascule introduit une discontinuité temporelle. La valeur de sortie à l’instant $t+\epsilon$ dépend de la valeur d’entrée à l’instant $t-\epsilon$, plutôt qu’à l’instant $t$. Prenez ici davantage de temps. Faites passer le même motif d’entrée dans un verrou D et une bascule D, puis comparez les diagrammes temporels côte à côte.
• Jour 19 (discipline temporelle). Setup, hold et métastabilité sont le moment où la conception numérique cesse d’être purement booléenne et admet son substrat analogique. La solution est d’assimiler l’article sur le délai de propagation : une fois admis que les portes prennent du temps et que ce temps varie, les règles temporelles deviennent inévitables.
• Jour 26 (intégration de l’ALU). Une ALU fonctionnelle possède des dizaines de fils. La tentation de simplement recopier le schéma et de passer à la suite est forte. Résistez-y. Suivez une opération bit par bit et vous conserverez le modèle mental. Si vous sautez cette étape, le jour 30 sera douloureux.
• Jour 30 (jour de l’intégration). C’est le jour où tout se cumule. Si vous avez sauté une construction précédente, cela se verra ici. La solution est de refuser sans concession de sauter une construction, tout au long du mois.

Les jours plus faciles qu’ils n’en ont l’air :

• Jour 5 (universalité de NAND/NOR). La preuve consiste en un circuit par porte. Une fois AND avec NAND compris, le reste devient mécanique.
• Jour 12 (multiplexeurs). Un multiplexeur est un routeur de fils avec une ligne de sélection. C’est toute l’idée. L’astuce du « multiplexeur générateur de fonctions » du jour 12 est réjouissante, mais facultative.
• Jours 22–24 (arithmétique). Si vous êtes arrivé en semaine 4, la famille des additionneurs devient un exercice à compléter. Profitez de ces jours faciles ; vous aurez besoin d’énergie plus tard.

Si vous avez envie de sauter la construction un jour donné, c’est le signal le plus fort que cette construction est précisément la partie à ne pas sauter. Lire sans construire est la façon de finir incapable de câbler un circuit que l’on sait décrire avec des mots.

À quoi ressemble la réussite à la fin de chaque semaine

Chaque semaine se termine par un point de contrôle. Si vous ne pouvez pas le franchir, reprenez la semaine avant de continuer.

• Fin de la semaine 1. À partir d’une table de vérité à 4 entrées, vous pouvez écrire une expression booléenne pour la sortie, dessiner le circuit correspondant au niveau des portes et prédire la sortie pour toute entrée. Vous pouvez lire le même circuit dessiné en notation ANSI ou IEC.
• Fin de la semaine 2. À partir d’une fonction booléenne, vous pouvez trouver une implémentation quasi minimale avec une carte de Karnaugh, décider si SOP ou POS est la moins coûteuse et choisir la bonne primitive (multiplexeur, décodeur, encodeur). Vous pouvez câbler un pilote 7 segments à partir de zéro.
• Fin de la semaine 3. À partir d’un circuit horodaté, vous pouvez prédire sa forme d’onde sur plusieurs cycles d’horloge. Vous pouvez construire un compteur de n’importe quel module. Vous pouvez expliquer pourquoi les temps setup et hold existent et ce qu’est la métastabilité.
• Fin de la semaine 4. Vous pouvez construire une ALU à $n$ bits qui prend en charge ADD, SUB, AND, OR et XOR avec une génération correcte des indicateurs. Vous pouvez câbler une RAM et l’adresser depuis un compteur.
• Fin du jour 30. Vous pouvez écrire un court programme dans le jeu d’instructions de votre CPU, le charger en RAM, déclencher le reset et regarder votre CPU l’exécuter.

Pourquoi cette feuille de route fonctionne

Nous avons vu des étudiants atteindre le même plateau au même endroit — la semaine 3, lorsque la logique séquentielle exige soudain une intuition du timing que la logique combinatoire n’avait jamais requise. La feuille de route place l’aisance avec les portes en amont, en semaine 1, afin qu’en semaine 3 vous n’essayiez pas aussi de vous rappeler ce que fait XOR. Elle alterne théorie et pratique pour qu’aucun concept ne reste abstrait plus de 24 heures. Et elle se termine par un vrai CPU, car c’est le moment où tout le domaine s’éclaire : chaque porte, chaque bascule et chaque multiplexeur que vous avez câblés se retrouve dans le même circuit, à faire un vrai travail.

La feuille de route est également conçue pour monter en charge. Si vous avez une semaine au lieu d’un mois, concentrez-vous sur les semaines 1 et 2, puis sur les jours 26–30 de la semaine 4 : vous aurez la colonne vertébrale sans toute la profondeur. Si vous avez un semestre, doublez le calendrier — chaque jour devient deux jours, le second étant consacré aux exercices et à un projet. Si vous avez une année, suivez les branches « après 30 jours » vers le pipeline, la correction d’erreurs et la virgule flottante.

Si vous enseignez la logique numérique, cette feuille de route est à vous. Donnez-la aux étudiants, personnalisez-la, dérivez-en votre propre version. Les articles sont en accès libre et les modèles du simulateur peuvent être remixés gratuitement. La seule demande est de construire quelque chose avec vos étudiants et de partager ce qu’ils construisent. Le matériel est plus amusant en public.

Variantes du programme de 30 jours

La feuille de route est volontairement orientée, mais considérez les jours comme une séquence plutôt que comme un contrat. Trois variantes méritent d’être signalées.

Version sprint (10 jours). Si vous avez déjà une expérience et voulez condenser le parcours, faites des jours 1–7 une journée chacun, puis réduisez les semaines 2–4 à un jour par semaine pour le concept le plus représentatif (cartes de Karnaugh, bascules D, ALU). Consacrez les jours 8–10 à la construction du CPU. Vous perdrez de la profondeur, mais garderez la colonne vertébrale.

Version marathon (90 jours). Triplez chaque journée en théorie + construction + extension. L’extension consiste à appliquer le concept du jour à un problème qui ne figurait pas dans l’article : construire un AND à 7 entrées avec des AND à 2 entrées, concevoir un compteur 6 bits, simuler une machine de Mealy qui détecte « 1011 » dans un flux série. C’est ainsi que vous transformez la feuille de route en cours.

Version guidée par le sujet. Si un seul résultat vous intéresse — par exemple concevoir des compteurs personnalisés pour un projet personnel — l’arbre de dépendances de la feuille de route vous indique quels jours suivre. Les compteurs ont besoin d’une horloge et de bascules, qui ont besoin de verrous, qui ont besoin de portes. Remontez du résultat vers les fondations et vous obtenez votre plan personnalisé.

Relier la feuille de route au reste du site

Le blog et le simulateur sont conçus comme une seule ressource. La feuille de route en est le chemin éditorial, mais vous pouvez aussi vous en écarter.

• L’index de la documentation regroupe les références de composants Logic publiées et renvoie séparément vers les ressources Relay, Electricity et le guide ciblé Analog Beta. Lorsque vous oubliez le rôle des entrées J et K d’une bascule JK, la référence du composant JK_FLIP_FLOP est plus rapide que de relire l’article ; consultez l’index au lieu de supposer que chaque composant possède sa propre page.
• L’index du blog est trié par ordre chronologique inverse et doté de tags. Filtrez par primaryTag pour trouver tous les articles d’une série.
• La page des tarifs explique quelles fonctionnalités sont gratuites (tout ce qui figure dans cette feuille de route) et lesquelles font partie de la formule Professional (export, modèles premium, leçons avancées).
• Si vous voulez une narration de type leçon avec des étapes en pause, consultez les leçons SimCast.

Si un sujet de cette feuille de route n’a pas encore d’article approfondi, c’est probablement qu’il figure dans notre file de rédaction — surveillez le flux du blog dans les prochains mois.

Notes finales

Ajoutez cette page à vos favoris. Abonnez-vous au flux RSS du blog DigiSim pour voir les nouveaux articles à mesure que le programme évolue — nous ajoutons environ un article par semaine et beaucoup s’insèrent directement dans la feuille de route comme approfondissements des jours existants. Lorsque vous aurez terminé, publiez votre CPU quelque part ; expliquer votre travail à quelqu’un d’autre est la façon de découvrir quelles parties vous avez réellement assimilées.

Le jour 1 n’est qu’à un clic. Ouvrez Logique numérique 101, affichez la démonstration interrupteur et lampe et commencez.

Commencez maintenant : la lecture du jour 1 est Logique numérique 101 et la construction est la démonstration interrupteur et lampe. Ajoutez cette page à vos favoris, abonnez-vous au flux du blog et revenez demain pour le jour 2.