Systemes Numeriques (SIN) - Semestre 1

PART A - Presentation Generale du Cours

Contexte de la formation

Les systemes numeriques sont au coeur de tous les equipements electroniques modernes : ordinateurs, smartphones, systemes embarques, automatismes industriels. Ce module introduit les fondements de la logique digitale et de la conception de circuits numeriques, competences indispensables pour tout technicien ou ingenieur en GEII. La maitrise du VHDL (langage de description materiel) permet de concevoir des systemes numeriques complexes sur FPGA.

Positionnement dans le cursus

• Semestre : S1 (1ere annee DUT GEII)
• Volume horaire : 65h (25h CM + 20h TD + 20h TP)
• Credits ECTS : 6
• Prerequis : Connaissances de base en mathematiques (binaire, booleen)
• Continuite : Logique Sequentielle (S2), Architectures Numeriques Avancees (S3-S4)

Public vise

Etudiants de premiere annee DUT GEII decouvrant la conception de circuits numeriques depuis les bases (portes logiques) jusqu'a la programmation FPGA en VHDL.

---

PART B: EXPERIENCE, CONTEXTE ET FONCTION

Objectifs pedagogiques

Competences en logique numerique :

• Maitriser les systemes de numeration et les conversions
• Comprendre et appliquer l'algebre de Boole
• Concevoir des circuits combinatoires et sequentiels
• Simplifier des fonctions logiques

Competences en VHDL et FPGA :

• Ecrire du code VHDL pour decrire des circuits
• Simuler et valider des designs numeriques
• Synthetiser et programmer des FPGA
• Utiliser l'environnement Quartus Prime (Intel/Altera)

Competences transversales :

• Analyser un probleme et le traduire en circuit logique
• Tester et deboguer des systemes numeriques
• Documenter ses conceptions

Programme detaille

1. Systemes de numeration (8h)

Bases numeriques :

Binaire (base 2) :

• Chiffres : 0, 1
• Exemple : 1011₂ = 1x2³ + 0x2² + 1x2¹ + 1x2⁰ = 11₁₀

Octal (base 8) :

• Chiffres : 0-7
• Utilise historiquement, moins courant aujourd'hui
• Conversion facile : 3 bits binaires = 1 chiffre octal

Hexadecimal (base 16) :

• Chiffres : 0-9, A-F (A=10, B=11, ..., F=15)
• Tres utilise en informatique (adresses memoire, couleurs RGB)
• Conversion : 4 bits binaires = 1 chiffre hexadecimal
• Exemple : 0xA3 = 10100011₂ = 163₁₀

Conversions entre bases :

Decimal → Binaire (divisions successives) :

45₁₀ → Binaire ?
45 / 2 = 22 reste 1  (bit de poids faible)
22 / 2 = 11 reste 0
11 / 2 = 5 reste 1
5 / 2 = 2 reste 1
2 / 2 = 1 reste 0
1 / 2 = 0 reste 1  (bit de poids fort)
Resultat : 101101₂

Binaire → Hexadecimal (groupes de 4 bits) :

11010110₂ = 1101 0110 = D6₁₆

Codes numeriques :

BCD (Binary Coded Decimal) :

• Chaque chiffre decimal code sur 4 bits
• Exemple : 95₁₀ = 1001 0101 (BCD) ≠ 1011111₂ (binaire pur)
• Utilise dans les afficheurs 7 segments

Code Gray :

• Un seul bit change entre deux valeurs consecutives
• Reduit les erreurs lors de transitions
• Utilise dans les encodeurs rotatifs

Decimal	Binaire	Gray
0	000	000
1	001	001
2	010	011
3	011	010
4	100	110

Code ASCII :

• 7 bits pour coder les caracteres (lettres, chiffres, symboles)
• Exemple : 'A' = 65₁₀ = 01000001₂

Arithmetique binaire :

Addition binaire :

  1011  (11)
+ 0110  (6)
-------
 10001  (17)

Regles : 0+0=0, 0+1=1, 1+1=10 (retenue)

Soustraction binaire (complement a 2) :

A - B = A + (-B)
-B = complement a 1 de B + 1

Exemple : 7 - 3
7 = 0111
3 = 0011 → Complement a 1 : 1100 → +1 : 1101 (-3)
0111 + 1101 = 10100 → on garde les 4 bits de poids faible : 0100 = 4

Representation des nombres signes :

• Signe + valeur absolue : 1 bit de signe + valeur
• Complement a 1 : inverser tous les bits
• Complement a 2 (le plus utilise) : complement a 1 + 1

Sur n bits, plage : -2^(n-1) a 2^(n-1)-1
Exemple sur 8 bits : -128 a +127

2. Algebre de Boole et logique combinatoire (15h)

Portes logiques fondamentales :

Porte	Symbole	Equation	Table de verite (A, B → S)
NOT (inverseur)	¬A ou A'	S = NOT A	0→1, 1→0
AND (ET)	A ∧ B	S = A AND B	00→0, 01→0, 10→0, 11→1
OR (OU)	A ∨ B	S = A OR B	00→0, 01→1, 10→1, 11→1
NAND (NON-ET)	A ↑ B	S = NOT (A AND B)	00→1, 01→1, 10→1, 11→0
NOR (NON-OU)	A ↓ B	S = NOT (A OR B)	00→1, 01→0, 10→0, 11→0
XOR (OU exclusif)	A ⊕ B	S = A XOR B	00→0, 01→1, 10→1, 11→0
XNOR	A ⊙ B	S = NOT (A XOR B)	00→1, 01→0, 10→0, 11→1

Proprietes de l'algebre de Boole :

• Commutativite : A AND B = B AND A
• Associativite : (A AND B) AND C = A AND (B AND C)
• Distributivite : A AND (B OR C) = (A AND B) OR (A AND C)
• Element neutre : A AND 1 = A ; A OR 0 = A
• Element absorbant : A AND 0 = 0 ; A OR 1 = 1
• Idempotence : A AND A = A ; A OR A = A
• Lois de Morgan :
  • NOT (A AND B) = (NOT A) OR (NOT B)
  • NOT (A OR B) = (NOT A) AND (NOT B)

Fonctions logiques et tables de verite :

Exemple : Fonction S = (A AND B) OR (NOT C)

A	B	C	NOT C	A AND B	S
0	0	0	1	0	1
0	0	1	0	0	0
0	1	0	1	0	1
0	1	1	0	0	0
1	0	0	1	0	1
1	0	1	0	0	0
1	1	0	1	1	1
1	1	1	0	1	1

Formes canoniques :

• Somme de produits (SOP / minterms) : S = ABC' + A'B'C + ...
• Produit de sommes (POS / maxterms) : S = (A+B+C')(A'+B'+C)...

Simplification par tableaux de Karnaugh :

Tableau de Karnaugh pour 3 variables (A, B, C) :

      C'  C
   +----+----+
AB' | 0  | 1  |
   +----+----+
A'B'| 2  | 3  |
   +----+----+
A'B | 6  | 7  |
   +----+----+
AB  | 4  | 5  |
   +----+----+

Methode :

1. Remplir le tableau avec les valeurs de sortie
2. Regrouper les '1' adjacents par puissances de 2 (1, 2, 4, 8...)
3. Extraire les termes simplifies

Circuits combinatoires usuels :

Demi-additionneur (Half Adder) :

• Entrees : A, B
• Sorties : Somme = A XOR B ; Retenue = A AND B

Additionneur complet (Full Adder) :

• Entrees : A, B, Cin (retenue entrante)
• Sorties : Somme = A XOR B XOR Cin ; Cout = (A AND B) OR (Cin AND (A XOR B))

Multiplexeur (MUX) :

• Selectionne une entree parmi plusieurs selon des signaux de selection
• MUX 4:1 → 4 entrees, 2 bits de selection, 1 sortie

Demultiplexeur (DEMUX) :

• Inverse du MUX : 1 entree vers n sorties

Decodeur :

• Convertit un code binaire en activation d'une sortie
• Decodeur 3:8 → 3 entrees, 8 sorties (une seule active a la fois)

Encodeur :

• Inverse du decodeur : plusieurs entrees → code binaire

Comparateur :

• Compare deux nombres binaires
• Sorties : A>B, A=B, A<B

3. Logique sequentielle (12h)

Difference combinatoire/sequentiel :

• Combinatoire : Sortie = f(Entrees actuelles)
• Sequentiel : Sortie = f(Entrees + Etat precedent)
  • Notion de memoire
  • Depend du temps (horloge)

Bascules (Flip-Flops) :

Bascule RS (Reset-Set) :

• 2 entrees : R (Reset), S (Set)
• 2 sorties : Q, Q'
• Etats : Set (Q=1), Reset (Q=0), Memoire, Interdit (R=S=1)

Bascule D (Data) :

• 1 entree : D
• Sur front d'horloge : Q ← D
• La plus utilisee (memorisation simple)

Bascule JK :

• 2 entrees : J, K
• J=K=0 : Memoire
• J=1, K=0 : Set
• J=0, K=1 : Reset
• J=K=1 : Toggle (Q ← NOT Q)

Bascule T (Toggle) :

• 1 entree : T
• Si T=1 : toggle a chaque front d'horloge

Registres :

• Registre parallele : n bascules D pour stocker n bits simultanement
• Registre a decalage : Les bits se decalent a chaque coup d'horloge
  • SISO (Serial In Serial Out)
  • SIPO (Serial In Parallel Out)
  • PISO (Parallel In Serial Out)
  • PIPO (Parallel In Parallel Out)

Compteurs :

Compteur asynchrone :

• Les bascules ne partagent pas la meme horloge
• Temps de propagation cumulatif
• Simple mais lent

Compteur synchrone :

• Toutes les bascules sur la meme horloge
• Plus rapide, prefere en pratique
• Compteur binaire, BCD, modulo-N

Machines a etats finis (FSM) :

Types :

• Moore : Sorties dependent uniquement de l'etat
• Mealy : Sorties dependent de l'etat ET des entrees

Diagramme d'etats :

     +------+  E=1  +------+
     |  S0  |------>|  S1  |
     +------+       +------+
        ^              |
        +--------------+
           E=0

Etapes de conception :

1. Diagramme d'etats
2. Table de transition
3. Codage des etats (binaire)
4. Equations des bascules et sorties
5. Implementation (schema ou VHDL)

4. Introduction au VHDL (20h)

VHDL = VHSIC Hardware Description Language

• Langage de description materiel (pas de programmation sequentielle classique)
• Decrit la structure et le comportement de circuits numeriques
• Synthetisable sur FPGA ou ASIC

Structure d'un code VHDL :

-- Bibliotheques
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

-- Entite (interface externe)
entity PorteAND is
    Port (
        A : in STD_LOGIC;
        B : in STD_LOGIC;
        S : out STD_LOGIC
    );
end PorteAND;

-- Architecture (comportement interne)
architecture Behavioral of PorteAND is
begin
    S <= A AND B;
end Behavioral;

Types de donnees :

• STD_LOGIC : '0', '1', 'Z' (haute impedance), 'X' (inconnu)
• STD_LOGIC_VECTOR : Bus de plusieurs bits
  • Exemple : signal bus : STD_LOGIC_VECTOR(7 downto 0);
• INTEGER : Nombres entiers
• BOOLEAN : TRUE, FALSE

Operateurs :

• Logiques : AND, OR, NOT, NAND, NOR, XOR, XNOR
• Arithmetiques : +, -, *, / (necessite use IEEE.NUMERIC_STD.ALL;)
• Comparaison : =, /=, <, >, <=, >=
• Concatenation : &

Affectations :

• Signal : <= (affectation concurrente, hors process)
• Variable : := (affectation sequentielle, dans process)

Processus (PROCESS) :

process(clk, reset)  -- Liste de sensibilite
begin
    if reset = '1' then
        compteur <= 0;
    elsif rising_edge(clk) then  -- Front montant d'horloge
        compteur <= compteur + 1;
    end if;
end process;

Structures de controle :

IF-THEN-ELSE :

if (condition) then
    -- instructions
elsif (autre_condition) then
    -- instructions
else
    -- instructions
end if;

CASE :

case sel is
    when "00" => sortie <= entree0;
    when "01" => sortie <= entree1;
    when "10" => sortie <= entree2;
    when others => sortie <= entree3;
end case;

FOR LOOP :

for i in 0 to 7 loop
    sortie(i) <= entree(7-i);  -- Inversion de bus
end loop;

Exemple complet : Compteur 8 bits

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity Compteur8bits is
    Port (
        clk : in STD_LOGIC;
        reset : in STD_LOGIC;
        enable : in STD_LOGIC;
        count : out STD_LOGIC_VECTOR(7 downto 0)
    );
end Compteur8bits;

architecture Behavioral of Compteur8bits is
    signal compteur : unsigned(7 downto 0) := (others => '0');
begin
    process(clk, reset)
    begin
        if reset = '1' then
            compteur <= (others => '0');
        elsif rising_edge(clk) then
            if enable = '1' then
                compteur <= compteur + 1;
            end if;
        end if;
    end process;

    count <= std_logic_vector(compteur);
end Behavioral;

Travaux pratiques

TP1 : Prise en main de Quartus Prime

• Installation et configuration
• Creation d'un projet
• Saisie schematique (portes logiques)
• Compilation et analyse
• Assignement des pins (carte FPGA)
• Programmation du FPGA

TP2 : Circuits combinatoires

• Decodeur BCD vers 7 segments
• Multiplexeur 4:1
• Additionneur 4 bits
• Tests et validation

TP3 : Introduction VHDL

• Portes logiques en VHDL
• Multiplexeur en VHDL
• Simulation avec ModelSim
• Synthese et programmation

TP4 : Logique sequentielle

• Bascules D et JK
• Registres a decalage
• Compteurs (up, down, modulo)
• Diviseur de frequence

TP5 : Machine a etats finis

• Conception d'une FSM (feu tricolore, distributeur, etc.)
• Implementation en VHDL
• Tests sur FPGA
• Validation fonctionnelle

---

PART C: ASPECTS TECHNIQUES

Outils de conception

Intel Quartus Prime

Installation :

• Version Lite (gratuite) : Jusqu'a 32k elements logiques
• Compatible Windows/Linux
• Telechargement : ~5-6 GB

Workflow de conception :

1. Creation projet : File → New Project Wizard
2. Ajout fichiers : .vhd, .v, ou schema
3. Compilation : Processing → Start Compilation (Ctrl+L)
4. Analyse : Compilation Report (ressources, timing, etc.)
5. Assignement pins : Assignments → Pin Planner
6. Programmation : Tools → Programmer

Analyses disponibles :

• RTL Viewer : Visualisation schema synthetise
• Technology Map Viewer : Mapping sur elements FPGA
• Timing Analyzer : Analyse des chemins critiques
• Resource Usage : LUTs, registres, memoire utilises

ModelSim (Simulation)

Fonctionnalites :

• Simulation comportementale (avant synthese)
• Simulation post-synthese (avec delais reels)
• Waveform viewer (chronogrammes)
• Testbenches VHDL

Exemple de testbench :

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity Compteur_TB is
end Compteur_TB;

architecture Behavioral of Compteur_TB is
    component Compteur8bits
        Port (clk, reset, enable : in STD_LOGIC;
              count : out STD_LOGIC_VECTOR(7 downto 0));
    end component;

    signal clk_tb, reset_tb, enable_tb : STD_LOGIC := '0';
    signal count_tb : STD_LOGIC_VECTOR(7 downto 0);
    constant clk_period : time := 10 ns;

begin
    UUT: Compteur8bits port map(clk_tb, reset_tb, enable_tb, count_tb);

    -- Generation horloge
    clk_process : process
    begin
        clk_tb <= '0';
        wait for clk_period/2;
        clk_tb <= '1';
        wait for clk_period/2;
    end process;

    -- Stimulus
    stim_proc: process
    begin
        reset_tb <= '1';
        wait for 20 ns;
        reset_tb <= '0';
        enable_tb <= '1';
        wait for 1000 ns;
        enable_tb <= '0';
        wait;
    end process;
end Behavioral;

Cartes FPGA utilisees

Altera/Intel Cyclone IV/V

Caracteristiques :

• 6K - 115K elements logiques
• Memoire embarquee (M9K blocks)
• PLL (Phase-Locked Loops) pour gestion horloges
• DSP blocks (multiplieurs materiels)
• GPIO configurable (LVTTL, LVCMOS, LVDS)

Cartes de developpement :

• DE0-Nano : Cyclone IV, compacte, ~80€
• DE1-SoC : Cyclone V + ARM Cortex-A9, ~200€
• DE2-115 : Cyclone IV, nombreux peripheriques, ~300€

Peripheriques typiques :

• LEDs, boutons poussoirs, switches
• Afficheurs 7 segments
• VGA/HDMI
• GPIO (connecteurs d'extension)
• USB, Ethernet (selon modele)

Methodologie de conception

Bonnes pratiques VHDL

Nommage :

• Signaux/variables : lowercase_avec_underscores
• Constantes : UPPERCASE
• Entites/architectures : CamelCase

Commentaires :

-- Commentaire ligne simple

--======================
-- Bloc de commentaire
--======================

Conception synchrone :

• Toujours utiliser une horloge unique si possible
• Eviter les logiques asynchrones complexes
• Reinitialiser les signaux (reset)

Testabilite :

• Creer des testbenches systematiquement
• Tester les cas limites
• Verifier le timing (setup/hold)

Debogage

Erreurs de compilation courantes :

• Signal not declared → Oublie de declarer le signal
• Multiple drivers → Signal assigne a plusieurs endroits
• Type mismatch → Conversion de type necessaire (std_logic_vector ↔ unsigned)

Outils de debogage :

• SignalTap II (Quartus) : Analyseur logique interne au FPGA
• Simulation : Toujours simuler avant de synthetiser
• LEDs de debug : Afficher des etats internes

---

PART D: ANALYSE ET REFLEXION

Evaluation des competences

Modalites d'evaluation

Controle continu (40%) :

• QCM theoriques (2x1h) : Algebre de Boole, logique sequentielle - 20%
• Tests pratiques Quartus (2x1h30) - 20%

Travaux pratiques (35%) :

• 5 TP notes avec rapports
• Evaluation : montage fonctionnel, code VHDL, tests, documentation

Projet (15%) :

• Mini-projet VHDL (machine a etats + compteur + affichage)
• Demo sur carte FPGA
• Code source commente
• Rapport technique

Examen terminal (10%) :

• Epreuve theorique (1h30)
• Tableaux de Karnaugh, chronogrammes, VHDL

Grille d'evaluation TP

Critere	Points
Fonctionnalite : Circuit fonctionne sur FPGA	/6
Code VHDL : Qualite, clarte, commentaires	/5
Simulation : Testbench et chronogrammes	/4
Tests : Validation complete	/3
Rapport : Clarte, schemas, analyses	/2
Total	/20

Competences acquises

Savoirs theoriques

• Maitriser l'algebre de Boole et les systemes de numeration
• Comprendre la logique combinatoire et sequentielle
• Connaitre les circuits numeriques fondamentaux
• Comprendre les principes des FPGA

Savoir-faire techniques

• Concevoir des circuits numeriques (combinatoires et sequentiels)
• Simplifier des fonctions logiques (Karnaugh)
• Programmer en VHDL
• Simuler et valider des designs numeriques
• Synthetiser et programmer des FPGA avec Quartus
• Deboguer des circuits numeriques

Savoir-etre

• Rigueur dans la conception (chronogrammes, timing)
• Methodologie de test et validation
• Documentation technique claire
• Travail en equipe sur projets

Progression et liens avec le cursus

Suite du parcours Systemes Numeriques

Semestre	Module	Contenu
S1	SIN 1	Logique combinatoire, sequentielle, VHDL de base
S2	Logique Sequentielle	FSM avancees, FIFO, memoires, bus
S3	Architectures Numeriques Avancees	Processeurs, pipelines, VHDL avance
S4	Projet FPGA	Conception systeme complet (SoC)

Liens avec les autres matieres

Matiere	Utilisation des systemes numeriques
Programmation	Similarites algorithmes/FSM
Informatique Embarquee	Microcontroleurs (logique interne)
Electronique	Interface analogique/numerique (ADC, DAC)
Automatique	Controleurs numeriques, regulateurs discrets
Telecommunications	Modulation/demodulation numerique

Indicateurs de reussite

Statistiques

Taux de reussite : 88%
Moyenne generale : 12.8/20

Difficultes frequentes :

• Confusion entre logique combinatoire et sequentielle
• Oubli de la liste de sensibilite dans les process
• Conversions de types en VHDL
• Timing (setup/hold violations)
• Simplification par Karnaugh (regroupements)

Cles de reussite :

• Dessiner les chronogrammes avant de coder
• Toujours simuler avant de synthetiser
• Commencer simple, complexifier progressivement
• Utiliser les exemples de code fournis
• Tester sur carte FPGA regulierement

Debouches et applications

Applications professionnelles

Metiers utilisant les FPGA/VHDL :

• Ingenieur FPGA (aeronautique, spatial, defense)
• Concepteur de circuits ASIC
• Ingenieur en traitement du signal numerique
• Developpeur systemes embarques critiques
• Architecte materiel (hardware architect)

Industries :

• Aeronautique/Spatial : Systemes critiques, resistance radiations
• Telecommunications : Modems, routeurs, 5G
• Automobile : ADAS, controle moteur
• Medical : Imagerie (echographie, IRM), appareils de diagnostic
• Finance : Trading haute frequence (FPGA pour latence ultra-faible)
• IA : Accelerateurs materiels (inference neuronale)

---

Ressources complementaires

Ouvrages de reference

Logique numerique :

1. Systemes logiques - Tome 1 et 2 - A. Vachoux (PPUR) - Reference francophone
2. Digital Design - M. Morris Mano (Pearson) - Classique mondial
3. Circuits numeriques et synthese logique - Jacques Weber (Eyrolles)

VHDL :

• VHDL - Du langage a la modelisation - Jacques Weber (Dunod)
• Free Range VHDL - Bryan Mealy (gratuit en ligne)
• VHDL for Engineers - Kenneth L. Short (Pearson)

Sites web et tutoriels

Cours en ligne :

• VHDL Whiz (vhdlwhiz.com) - Tutoriels video gratuits
• Nandland (nandland.com) - Projets FPGA pour debutants
• FPGA4Fun (fpga4fun.com) - Nombreux exemples VHDL

Forums et communautes :

• Reddit : r/FPGA
• EDAboard : Forum specialise FPGA/VHDL
• Stack Overflow : Tag [vhdl]

Simulateurs en ligne :

• CircuitVerse (circuitverse.org) - Logique digitale interactive
• EDA Playground (edaplayground.com) - Simulation VHDL en ligne

Logiciels libres alternatifs

• GHDL : Simulateur VHDL open source
• GTKWave : Visualisateur de formes d'ondes
• Icarus Verilog : Si vous voulez apprendre Verilog aussi

---

Conseils methodologiques

Pour reussir en systemes numeriques

Pendant les cours/TD :

• Dessiner les circuits au fur et a mesure
• Refaire les simplifications de Karnaugh chez soi
• Comprendre les chronogrammes (temps = horizontal)

En TP :

• Lire le sujet entierement avant de commencer
• Concevoir sur papier avant de coder
• Simuler systematiquement avant de programmer le FPGA
• Sauvegarder frequemment son projet
• Tester progressivement (fonction par fonction)

Travail personnel (2-3h/semaine) :

• Refaire les exercices de simplification
• Creer ses propres petits circuits en VHDL
• Regarder des tutoriels video (Nandland, VHDL Whiz)
• Pratiquer les conversions de bases

Erreurs a eviter

• Oublier rising_edge(clk) dans les process synchrones
• Melanger affectations <= et :=
• Negliger les types (STD_LOGIC vs INTEGER vs UNSIGNED)
• Creer des boucles combinatoires (A depend de A)
• Ne pas tester les cas limites (reset, overflow, etc.)

Bonnes pratiques :

• Toujours declarer un signal de reset
• Utiliser des noms de signaux explicites
• Commenter son code VHDL
• Verifier le Resource Usage apres compilation
• Documenter ses montages avec schemas

---

Bon courage dans la decouverte passionnante des systemes numeriques !

"In theory, theory and practice are the same. In practice, they are not." - Yogi Berra

En systemes numeriques, la simulation et les tests sur materiel reel sont essentiels. N'hesitez pas a experimenter sur les cartes FPGA !

• Programmation : Structures de controle et algorithmique
• ER (Electronique et Realisation) : Interface analogique/numerique
• Mathematiques : Algebre de Boole

Ressources complementaires

• Documentation Intel Quartus
• Tutoriels VHDL
• Datasheets des composants FPGA

45₁₀ → Binary?
45 / 2 = 22 remainder 1  (least significant bit)
22 / 2 = 11 remainder 0
11 / 2 = 5 remainder 1
5 / 2 = 2 remainder 1
2 / 2 = 1 remainder 0
1 / 2 = 0 remainder 1  (most significant bit)
Result: 101101₂

11010110₂ = 1101 0110 = D6₁₆

  1011  (11)
+ 0110  (6)
-------
 10001  (17)

Rules: 0+0=0, 0+1=1, 1+1=10 (carry)

A - B = A + (-B)
-B = one's complement of B + 1

Example: 7 - 3
7 = 0111
3 = 0011 → One's complement: 1100 → +1: 1101 (-3)
0111 + 1101 = 10100 → keep the 4 least significant bits: 0100 = 4

      C'  C
   +----+----+
AB' | 0  | 1  |
   +----+----+
A'B'| 2  | 3  |
   +----+----+
A'B | 6  | 7  |
   +----+----+
AB  | 4  | 5  |
   +----+----+

     +------+  E=1  +------+
     |  S0  |------>|  S1  |
     +------+       +------+
        ^              |
        +--------------+
           E=0

-- Libraries
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

-- Entity (external interface)
entity PorteAND is
    Port (
        A : in STD_LOGIC;
        B : in STD_LOGIC;
        S : out STD_LOGIC
    );
end PorteAND;

-- Architecture (internal behavior)
architecture Behavioral of PorteAND is
begin
    S <= A AND B;
end Behavioral;

process(clk, reset)  -- Sensitivity list
begin
    if reset = '1' then
        counter <= 0;
    elsif rising_edge(clk) then  -- Rising clock edge
        counter <= counter + 1;
    end if;
end process;

if (condition) then
    -- instructions
elsif (other_condition) then
    -- instructions
else
    -- instructions
end if;

case sel is
    when "00" => output <= input0;
    when "01" => output <= input1;
    when "10" => output <= input2;
    when others => output <= input3;
end case;

for i in 0 to 7 loop
    output(i) <= input(7-i);  -- Bus inversion
end loop;

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity Counter8bits is
    Port (
        clk : in STD_LOGIC;
        reset : in STD_LOGIC;
        enable : in STD_LOGIC;
        count : out STD_LOGIC_VECTOR(7 downto 0)
    );
end Counter8bits;

architecture Behavioral of Counter8bits is
    signal counter : unsigned(7 downto 0) := (others => '0');
begin
    process(clk, reset)
    begin
        if reset = '1' then
            counter <= (others => '0');
        elsif rising_edge(clk) then
            if enable = '1' then
                counter <= counter + 1;
            end if;
        end if;
    end process;

    count <= std_logic_vector(counter);
end Behavioral;

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity Counter_TB is
end Counter_TB;

architecture Behavioral of Counter_TB is
    component Counter8bits
        Port (clk, reset, enable : in STD_LOGIC;
              count : out STD_LOGIC_VECTOR(7 downto 0));
    end component;

    signal clk_tb, reset_tb, enable_tb : STD_LOGIC := '0';
    signal count_tb : STD_LOGIC_VECTOR(7 downto 0);
    constant clk_period : time := 10 ns;

begin
    UUT: Counter8bits port map(clk_tb, reset_tb, enable_tb, count_tb);

    -- Clock generation
    clk_process : process
    begin
        clk_tb <= '0';
        wait for clk_period/2;
        clk_tb <= '1';
        wait for clk_period/2;
    end process;

    -- Stimulus
    stim_proc: process
    begin
        reset_tb <= '1';
        wait for 20 ns;
        reset_tb <= '0';
        enable_tb <= '1';
        wait for 1000 ns;
        enable_tb <= '0';
        wait;
    end process;
end Behavioral;

-- Single line comment

--======================
-- Comment block
--======================