C2 — Couches bassesDans le dialogue d’impression, choisissez « Enregistrer au format PDF » comme destination.
Retour

Licence 1 · Réseaux

Cours 2Couches basses

Descendre au fil et à la trame : comment les bits circulent, et comment une machine en atteint une autre sur le même lien.

2 chapitres · 12 h de travail estimé

  1. 1. Couche physique5 h
  2. 2. Couche liaison7 h

Chapitre 1 · 5 h

Couche physique

Signal, codage, modulation ; supports cuivre, fibre et sans-fil ; débit binaire et bruit ; répéteur et concentrateur.

Nous voici tout en bas de la pile, au contact du matériel. La couche physique répond à la question la plus concrète du cours : comment un 0 et un 1 — des abstractions — deviennent-ils quelque chose de réel qui traverse une pièce, une ville, un océan ? La réponse est un signal physique : une tension sur un fil de cuivre, une impulsion de lumière dans une fibre, une onde radio dans l'air.

C'est la couche la moins « informatique » et la plus physique, mais elle porte une leçon qui vaut pour tout le cours : on ne met jamais les bits bruts sur le support. Entre le bit et le support, il y a toujours un codage — et comprendre pourquoi est l'objet de ce chapitre.

Du bit au signal : signal, codage, modulation

Trois notions, qu'il faut distinguer.

Un signal est une grandeur physique qui varie dans le temps et qu'on peut mesurer à l'autre bout : une tension, une intensité lumineuse, l'amplitude d'une onde. C'est le support matériel de l'information.

Le codage (en bande de base) associe des bits à des niveaux de signal directement, sans onde porteuse — typiquement sur un câble. Le codage naïf NRZ met une tension haute pour 1, basse pour 0. Il a un défaut fatal, développé plus bas : une longue série de bits identiques devient un niveau constant, et le récepteur, qui n'a pas l'horloge de l'émetteur, perd le compte.

La modulation est employée quand on doit transmettre sur une onde porteuse — radio, Wi-Fi, ADSL. On fait varier une caractéristique de l'onde (son amplitude, sa fréquence ou sa phase) au rythme des données. C'est ce qui permet de faire passer des bits dans l'air ou sur une ligne téléphonique conçue pour la voix.

Pourquoi coder : l'horloge dans le signal

Le point central du chapitre. Le récepteur doit savoir quand commence et finit chaque bit — c'est le problème de la synchronisation d'horloge. Avec NRZ, 00000000 produit un niveau bas constant : aucun repère, et le récepteur ne peut pas distinguer huit zéros de sept ou de neuf.

La solution des bons codages est d'intégrer l'horloge dans le signal lui-même. Le codage Manchester (celui de l'Ethernet historique) code chaque bit par une transition au milieu de l'intervalle : il y a donc toujours une transition par bit, sur laquelle le récepteur se resynchronise, même sur une longue série identique.

Ce gain a un prix, et ce compromis est typique de la couche physique : Manchester exige deux demi-temps par bit, donc pour une même vitesse de signal, le débit binaire utile est deux fois plus faible. Fiabilité contre débit — on retrouvera cet arbitrage partout. L'exercice vous fera coder les deux et compter les transitions ; la différence sur 00000000 est spectaculaire.

Débit binaire et bruit

Deux limites physiques bornent ce qu'un support peut transporter.

Le débit binaire est le nombre de bits par seconde effectivement transmis. Il ne se confond pas avec la rapidité de modulation (le nombre de changements de signal par seconde) : un symbole peut coder plusieurs bits à la fois. C'est ainsi qu'on atteint de hauts débits sans augmenter indéfiniment la fréquence du signal.

Le bruit est toute perturbation qui altère le signal : interférences électromagnétiques, atténuation avec la distance, diaphonie entre fils voisins. Plus le bruit est fort, plus il devient difficile de distinguer les niveaux, et plus le débit atteignable chute. Il existe une limite théorique — le théorème de Shannon-Hartley — qui relie le débit maximal à la bande passante du support et au rapport signal/bruit : au-delà, aucune ingéniosité de codage ne permet de transmettre sans erreur. On retiendra le principe qualitatif : plus de bruit, moins de débit fiable.

C'est ce qui explique qu'un lien se dégrade avec la distance et l'environnement, et pourquoi les erreurs de transmission sont inévitables — d'où la détection d'erreurs de la couche liaison, au chapitre 4.

Quiz · 1 question

Pourquoi le codage NRZ (1 = tension haute, 0 = tension basse) pose-t-il problème sur une longue série de zéros, et que fait Manchester pour l'éviter ?

  • NRZ consomme trop d'énergie ; Manchester réduit la tensionénergie
  • NRZ produit un niveau constant sans repère, et le récepteur perd la synchronisation ; Manchester garantit une transition par bit, ce qui embarque l'horloge dans le signalsynchronisation d'horloge
  • NRZ est trop lent ; Manchester double le débit binairedébit

Réponse : Sur « 00000000 », NRZ maintient une tension basse constante : aucune transition, donc aucun repère temporel. Le récepteur, qui ne partage pas l'horloge de l'émetteur, ne peut plus compter les bits. Manchester code chaque bit par une transition au milieu de l'intervalle : il y a toujours au moins une transition par bit, sur laquelle le récepteur se resynchronise. Le signal porte ainsi sa propre horloge. En contrepartie, Manchester est moins efficace en débit (deux demi-temps par bit), pas plus rapide.

Les supports

Le support physique conditionne le débit, la distance et la sensibilité au bruit. Trois grandes familles :

SupportPrincipeForcesLimites
Cuivre (paire torsadée)tension électriquebon marché, simplesensible au bruit, atténuation rapide (~100 m)
Fibre optiqueimpulsions de lumièretrès haut débit, longues distances, insensible aux interférencescoût, fragilité, raccordement délicat
Sans-fil (radio)ondes électromagnétiquesmobilité, pas de câblagepartagé, sensible au bruit et aux obstacles, sécurité (chapitre 8)

La paire torsadée est torsadée précisément pour réduire le bruit : les torsades annulent une grande partie des interférences captées par les deux fils. La fibre domine les longues distances et les cœurs de réseau — c'est elle qui traverse les océans. Le sans-fil apporte la mobilité, au prix d'un médium partagé entre tous ceux qui sont à portée, ce qui crée des problèmes d'accès (chapitre 4) et de sécurité (chapitre 8) que les liens filaires n'ont pas.

Les équipements de couche 1

Deux équipements travaillent au seul niveau du signal, sans rien comprendre à ce qu'ils transportent — ce sont des équipements « de couche 1 ».

Le répéteur régénère un signal affaibli pour prolonger une liaison au-delà de la distance où le bruit l'aurait rendu illisible. Il ne fait qu'amplifier et remettre en forme : il ne lit aucune adresse, ne prend aucune décision.

Le concentrateur (hub) est un répéteur à plusieurs ports : tout ce qui arrive sur un port est recopié sur tous les autres. C'est un équipement obsolète, et il est instructif de savoir pourquoi : en diffusant tout à tout le monde, il gaspille la bande passante et fait entrer toutes les machines en concurrence sur le médium. Son successeur, le commutateur (couche 2, chapitre 4), prend au contraire des décisions en lisant les adresses — parce qu'il travaille une couche plus haut. C'est un premier exemple concret de ce que « monter d'une couche » apporte.

Quiz · 1 question

Un technicien doit prolonger une liaison réseau au-delà de la distance où le signal devient trop faible. Quel équipement de couche 1 emploie-t-il, et que fait-il exactement ?

  • Un commutateur, qui lit les adresses et choisit le bon portdécision par adresse MAC
  • Un répéteur, qui régénère et réamplifie le signal sans lire aucune adresse ni prendre de décisionrégénération du signal
  • Un routeur, qui achemine selon l'adresse IProutage IP

Réponse : Prolonger une liaison affaiblie est un problème de SIGNAL, donc de couche 1 : le répéteur régénère et réamplifie le signal pour qu'il reste lisible plus loin, sans jamais lire d'adresse ni décider quoi que ce soit. Le commutateur (couche 2) et le routeur (couche 3) prennent des décisions à partir d'adresses — ils travaillent plus haut dans la pile, sur le contenu et non sur le seul signal. Chaque équipement opère à sa couche : c'est ce qui permet de raisonner sur un réseau.

À vous

L'exercice illustre le cœur du chapitre : pourquoi on ne met jamais les bits bruts sur le fil. Vous codez une suite de bits en NRZ, puis en Manchester, et vous comptez les transitions du signal sur 00000000.

Le contraste est net : NRZ ne produit aucune transition — le récepteur est perdu —, tandis que Manchester en garantit une par bit, ce qui embarque l'horloge dans le signal lui-même. Vous mesurez au passage le prix de cette fiabilité : deux demi-temps par bit, donc un débit utile moindre. C'est le premier des nombreux compromis de la matière.

Exercice de code

Codez une suite de bits en NRZ puis en Manchester, et comptez les transitions du signal sur « 00000000 ». Vous verrez pourquoi on ne met jamais les bits bruts sur le fil : un bon codage porte l'horloge, ce qui permet au récepteur de rester synchronisé même sur une longue série de zéros.

Point de départ

// Sur un fil, un bit est une TENSION. Le codage le plus naïf, NRZ :
//   1 -> tension haute, 0 -> tension basse, pendant toute la durée du bit.
// Problème : "00000000" = tension basse constante. Le récepteur, qui n'a pas
// l'horloge de l'émetteur, ne sait plus COMBIEN de 0 il y a — il perd le compte.

function nrz(bits) {
  return [...bits].map((b) => (b === "1" ? "H" : "B")).join("");
}

// ── À VOUS : le codage Manchester ───────────────────────────────────────────
// Manchester code chaque bit par une TRANSITION au milieu de l'intervalle :
//   1 -> Bas puis Haut  ("BH")
//   0 -> Haut puis Bas  ("HB")
// Ainsi il y a TOUJOURS une transition par bit : le récepteur récupère
// l'horloge à chaque bit, même sur une longue série de 0.
function manchester(bits) {
  let sortie = "";
  for (const b of bits) {
    // à compléter : ajouter "BH" pour un 1, "HB" pour un 0
  }
  return sortie;
}

// ── Compter les transitions (les fronts de synchronisation) ─────────────────
function transitions(signal) {
  let n = 0;
  for (let i = 1; i < signal.length; i++) if (signal[i] !== signal[i - 1]) n++;
  return n;
}

// ── Vérification ────────────────────────────────────────────────────────────
const bits = "00000000";
console.log("bits        :", bits);
console.log("NRZ         :", nrz(bits),        "-> transitions :", transitions(nrz(bits)));
console.log("Manchester  :", manchester(bits), "-> transitions :", transitions(manchester(bits)));
console.log("");
console.log("décodage attendu Manchester('1010') = " + manchester("1010"));

Solution

function manchester(bits) {
  let sortie = "";
  for (const b of bits) {
    sortie += (b === "1") ? "BH" : "HB";   // toujours une transition au milieu
  }
  return sortie;
}
// bits "00000000" :
//   NRZ        : BBBBBBBB       -> 0 transition  (le récepteur est perdu)
//   Manchester : HBHBHBHBHBHBHBHB -> ~15 transitions (une par bit garantie)
// Manchester('1010') = BHHBBHHB

// ── Ce que l'exercice enseigne ──────────────────────────────────────────────
//
// 1. On ne met JAMAIS les bits bruts sur le support. Un signal doit être
//    CODÉ pour être décodable de façon fiable — c'est le rôle de la couche
//    physique. Le codage naïf NRZ échoue sur les longues séries identiques :
//    sans transition, le récepteur perd la cadence et ne sait plus combien
//    de bits sont passés.
//
// 2. Un bon codage porte l'HORLOGE dans le signal lui-même. Manchester
//    garantit une transition par bit : le récepteur se resynchronise à
//    chaque bit, sans horloge partagée. Le prix : il faut deux « demi-temps »
//    par bit, donc le débit binaire utile est deux fois plus faible pour une
//    même vitesse de signal. C'est un compromis fiabilité / débit typique de
//    la couche physique.
//
// 3. Ces choix vivent ENTIÈREMENT dans la couche 1 : les couches au-dessus
//    (liaison, réseau...) ne voient que des bits propres et ignorent
//    totalement comment ils ont voyagé sur le support — cuivre, fibre ou
//    ondes. C'est l'indépendance des couches du chapitre 2, tout en bas de
//    la pile.

Ce que la suite en fait

La couche physique achemine des bits — mais elle les achemine avec des erreurs inévitables (le bruit), et sans savoir à qui ils sont destinés sur un réseau local. La couche au-dessus règle ces deux points.

Le chapitre 4, la couche liaison, regroupe les bits en trames, leur donne une adresse MAC pour désigner la machine voisine, détecte les erreurs de transmission (par parité et CRC — la conséquence directe du bruit vu ici), et introduit l'équipement qui a remplacé le concentrateur : le commutateur. On y verra aussi Ethernet, ARP et une première approche du Wi-Fi.

À retenir

Flashcards · 4 cartes

Pourquoi ne met-on jamais les bits bruts sur le support, et que fait un bon codage comme Manchester ?
Parce que le récepteur doit se synchroniser : avec le codage naïf NRZ, une longue série de bits identiques donne un niveau constant sans repère, et le récepteur perd le compte. Un bon codage embarque l'HORLOGE dans le signal : Manchester code chaque bit par une transition au milieu de l'intervalle, garantissant une transition par bit. Prix : deux demi-temps par bit, donc un débit utile deux fois moindre — un compromis fiabilité/débit typique de la couche physique.
Quelle est la différence entre codage et modulation ?
Le codage (en bande de base) associe directement des bits à des niveaux de signal, sans onde porteuse — typiquement sur câble (NRZ, Manchester). La modulation fait varier une caractéristique d'une onde PORTEUSE — amplitude, fréquence ou phase — au rythme des données, quand on transmet sur radio, Wi-Fi ou ligne téléphonique. On code sur le cuivre nu, on module sur les ondes.
Comment le bruit limite-t-il le débit d'un support ?
Le bruit (interférences, atténuation avec la distance, diaphonie) rend les niveaux de signal plus difficiles à distinguer : plus il est fort, plus le débit fiable CHUTE. Une limite théorique (Shannon-Hartley) relie le débit maximal à la bande passante et au rapport signal/bruit — au-delà, aucun codage ne transmet sans erreur. C'est pourquoi les erreurs sont inévitables, d'où la détection d'erreurs de la couche liaison (chapitre 4).
Qu'est-ce qu'un répéteur et un concentrateur (hub), et pourquoi le hub est-il obsolète ?
Ce sont des équipements de couche 1, qui n'agissent que sur le signal. Le répéteur régénère et réamplifie un signal affaibli pour prolonger une liaison, sans lire d'adresse. Le concentrateur est un répéteur multiport qui recopie tout ce qu'il reçoit sur TOUS les ports : il gaspille la bande passante et met les machines en concurrence sur le médium. Le commutateur (couche 2) l'a remplacé en prenant des décisions à partir des adresses.

Chapitre 2 · 7 h

Couche liaison

Trame et adresse MAC ; détection d'erreurs par parité et CRC ; Ethernet et CSMA/CD ; commutateur et table de commutation ; ARP ; introduction au Wi-Fi.

La couche physique (chapitre 3) achemine des bits, mais bruts et faillibles : elle ne dit à qui ils sont destinés sur le réseau local, ni ne signale s'ils sont arrivés intacts. La couche liaison répond à ces deux manques. Elle regroupe les bits en trames, donne à chaque machine une adresse locale, détecte les erreurs de transmission, et organise le partage du médium quand plusieurs machines veulent parler en même temps.

C'est la couche du réseau local : elle gère la communication entre machines d'un même lien — votre PC et le commutateur de la salle, votre téléphone et la borne Wi-Fi. Le passage au monde, d'un réseau à l'autre, sera l'affaire de la couche réseau (chapitre 5).

La trame et l'adresse MAC

L'unité de la couche liaison est la trame : un bloc de bits structuré, avec un en-tête, les données, et un contrôle d'erreur en fin. C'est l'enveloppe dans laquelle voyage le paquet de la couche supérieure (encapsulation, chapitre 2).

Chaque interface réseau possède une adresse MAC (Media Access Control) : un identifiant de 48 bits, écrit en hexadécimal comme a4:83:e7:2c:1f:90, gravé par le fabricant. Deux propriétés importantes :

  • elle est censée être unique au monde — les premiers octets identifient le fabricant ;
  • elle est plate et locale : elle ne porte aucune information de localisation. Elle désigne une carte réseau, pas un endroit dans le réseau.

C'est cette dernière propriété qui explique pourquoi la MAC ne suffit pas et pourquoi il faudra l'adresse IP au chapitre 5. On peut retrouver une machine par sa MAC sur le réseau local, mais pas la router à travers le monde : rien, dans une MAC, ne dit de quel côté de la planète elle se trouve. La MAC est une adresse de voisinage ; l'IP sera une adresse de destination globale. Retenez ce couple, il structure tout le reste du cours.

Détecter les erreurs : parité et CRC

Le bruit de la couche physique (chapitre 3) rend les erreurs de transmission inévitables. La couche liaison les détecte grâce à un code de contrôle ajouté à la trame : l'émetteur le calcule sur les données, le récepteur le recalcule et compare. S'ils diffèrent, la trame est altérée — et on la jette.

Deux mécanismes, d'inégale robustesse :

  • La parité ajoute un bit qui rend pair (ou impair) le nombre de 1. Simple, mais faible : elle ne détecte qu'un nombre impair d'erreurs — deux bits inversés lui échappent.
  • Le CRC (contrôle de redondance cyclique) est celui qu'emploie réellement Ethernet. Fondé sur une division polynomiale, il détecte quasiment toutes les erreurs réalistes — toutes les rafales courtes, la grande majorité des autres. C'est le standard.

Un point de vocabulaire capital, qui reviendra au chapitre 7 : la couche liaison détecte les erreurs, elle ne les corrige pas. Une trame erronée est simplement écartée. La rattraper — la retransmettre — n'est pas son rôle ; ce sera celui de TCP, à la couche transport. Détecter et corriger sont deux fonctions distinctes, situées à deux couches distinctes.

Quiz · 1 question

Une trame Ethernet arrive avec un CRC qui ne correspond pas aux données. Que fait la couche liaison, et qui se charge éventuellement de récupérer l'information perdue ?

  • Elle corrige automatiquement les bits erronés grâce au CRCcorrection par CRC
  • Elle jette la trame (détection sans correction) ; la récupération éventuelle relèvera de la couche transport (TCP), par retransmissiondétecter ≠ corriger
  • Elle renvoie immédiatement une demande de retransmission à l'émetteurretransmission en couche 2

Réponse : Le CRC DÉTECTE l'erreur, il ne la corrige pas : la couche liaison se contente de jeter la trame altérée. Récupérer l'information — s'apercevoir qu'un segment manque et le redemander — relève de la couche TRANSPORT, où TCP assure la fiabilité par retransmission (chapitre 7). Détecter (couche 2) et corriger par retransmission (couche 4) sont deux fonctions à deux couches différentes : c'est la séparation des préoccupations du chapitre 2.

Ethernet et l'accès au médium : CSMA/CD

Ethernet est la technologie de réseau local filaire dominante. Historiquement, toutes les machines partageaient un même câble (topologie en bus, chapitre 1) — d'où un problème : si deux machines émettent en même temps, les signaux se mélangent, c'est une collision, et les deux trames sont perdues.

Ethernet le résout par CSMA/CD (Carrier Sense Multiple Access with Collision Detection), un protocole dont le nom décrit l'algorithme :

  1. Écouter avant d'émettre (carrier sense) : si le médium est occupé, attendre.
  2. Émettre si le médium est libre — mais continuer d'écouter.
  3. Détecter une collision (collision detection) : si deux machines ont émis quasi simultanément.
  4. En cas de collision, arrêter, attendre un délai aléatoire, puis réessayer.

Le délai aléatoire est la clé : sans lui, les deux machines réessaieraient en même temps et entreraient à nouveau en collision indéfiniment. Le hasard désynchronise les tentatives.

CSMA/CD appartient largement à l'histoire, et il faut comprendre pourquoi : l'Ethernet moderne est commuté (topologie en étoile autour d'un commutateur), et chaque machine a son propre lien dédié en duplex intégral. Il n'y a plus de collisions, donc plus besoin de CSMA/CD. Le protocole reste au programme parce qu'il éclaire la nature d'un médium partagé — et parce que le Wi-Fi, où le partage est inévitable, emploie un mécanisme cousin.

Le commutateur et sa table

Le commutateur (switch) est l'équipement central du réseau local moderne, et l'exemple type de ce qu'apporte la couche 2 par rapport à la couche 1. Là où le concentrateur (chapitre 3) recopiait bêtement tout sur tous les ports, le commutateur lit les adresses MAC et n'envoie chaque trame qu'au bon port.

Sa force est qu'il apprend tout seul. Il tient une table de commutation (MAC → port), qu'il remplit en observant les trames : quand une trame arrive d'une MAC sur un port, il note « cette MAC est joignable par ce port ». Ensuite :

  • si la destination est connue dans la table, il envoie sur son port uniquement — envoi ciblé ;
  • si elle est inconnue (ou s'il s'agit d'une diffusion), il inonde : il envoie sur tous les ports sauf celui d'entrée — le seul cas où il ressemble encore à un hub.

Le bénéfice est double : le trafic inutile disparaît (chaque machine ne voit que ce qui la concerne), et les liens ne sont plus partagés (plus de collisions). L'exercice vous fera coder cette table qui se remplit d'elle-même — l'auto-apprentissage est l'idée à emporter.

ARP : du monde IP au monde MAC

Il manque un maillon, et il est essentiel. Les applications et la couche réseau raisonnent en adresses IP (chapitre 5) ; mais pour livrer une trame sur le réseau local, il faut l'adresse MAC du destinataire. Comment passer de l'une à l'autre ?

C'est le rôle d'ARP (Address Resolution Protocol). Pour joindre l'IP 192.168.1.10 sur son réseau local, une machine diffuse une question à tout le monde : « qui a l'IP 192.168.1.10 ? donne-moi ta MAC ». La machine concernée répond avec sa MAC, et l'émetteur met en cache la correspondance pour ne pas redemander à chaque trame.

ARP est le pont entre la couche 3 (IP, global) et la couche 2 (MAC, local) : il traduit une adresse de destination globale en adresse de voisinage. C'est un rouage discret mais permanent — et son absence d'authentification en fait une cible d'attaque (l'usurpation ARP, que le cours de cybersécurité de L3 reprendra). Retenez-le comme la charnière entre les deux mondes d'adressage.

Un mot sur le Wi-Fi

Le Wi-Fi (norme 802.11) est la couche liaison du sans-fil. Il partage l'esprit d'Ethernet — trames, adresses MAC — mais avec une contrainte que le filaire commuté a supprimée : le médium est intrinsèquement partagé. Toutes les machines à portée émettent sur les mêmes ondes.

Il ne peut donc pas revenir à un lien dédié, et il emploie un cousin de CSMA/CD : CSMA/CA (Collision Avoidance). La différence tient dans le dernier sigle — sur un lien radio, une machine ne peut pas toujours détecter une collision pendant qu'elle émet (elle n'entend pas les autres). Elle cherche donc à les éviter en amont, par de l'écoute et des délais d'attente. Le Wi-Fi ajoute aussi le chiffrement (WPA2, WPA3) : puisque n'importe qui à portée capte les trames, la confidentialité doit être assurée par la cryptographie — un sujet que le chapitre 8 effleurera et que le cours de cybérsécurité approfondira.

Quiz · 1 question

Une machine connaît l'adresse IP de destination sur son réseau local, mais doit obtenir l'adresse MAC correspondante pour émettre la trame. Quel protocole emploie-t-elle, et comment procède-t-il ?

  • DNS, qui traduit les noms en adressesrésolution de noms
  • ARP, qui diffuse « qui a cette IP ? » sur le réseau local ; la machine concernée répond avec sa MAC, mise ensuite en cacheIP → MAC par diffusion
  • CSMA/CD, qui détecte l'adresse par écoute du médiumaccès au médium

Réponse : Passer d'une adresse IP (couche 3, globale) à l'adresse MAC (couche 2, locale) nécessaire pour livrer la trame est le rôle exact d'ARP. Il diffuse la question « qui a l'IP X ? » à tout le réseau local ; la machine visée répond avec sa MAC, que l'émetteur met en cache. DNS traduit des NOMS en adresses IP (chapitre 8), ce qui est un problème différent ; CSMA/CD gère l'accès au médium partagé, pas la résolution d'adresses. ARP est la charnière entre le monde IP et le monde MAC.

À vous

L'exercice réunit les deux idées maîtresses de la couche liaison. D'abord, la table du commutateur : vous la voyez se remplir toute seule à mesure que les trames passent, et le commutateur cesser d'inonder dès qu'il connaît une destination — c'est ce qui le distingue du hub. Ensuite, la détection d'erreur : vous calculez un contrôle à l'émission, le recalculez à la réception, et repérez une trame altérée.

Gardez en tête la nuance que le TP met en évidence : on détecte ici, on ne corrige pas — et notre parité est bien plus faible que le CRC réel, même si le principe est identique.

Exercice de code

Implémentez deux mécanismes de la couche liaison : la table d'un commutateur qui APPREND quelle adresse MAC est sur quel port (et n'inonde que faute de mieux), et une détection d'erreur par contrôle recalculé à la réception (l'esprit du CRC). Distinguez bien détecter une erreur et la corriger.

Point de départ

// ── Partie A : la table de commutation qui s'apprend ────────────────────────
// Un commutateur relie des machines à des ports. Contrairement au hub (qui
// recopie partout), il APPREND quelle MAC est sur quel port en observant les
// trames qui passent, et n'envoie ensuite qu'au bon port.

const table = {};  // MAC source -> port (la table se remplit toute seule)

// À VOUS : compléter apprendre() et decider().
function traiter(macSrc, macDst, portEntree) {
  // 1. apprendre : la source macSrc est joignable par portEntree
  // à compléter : table[macSrc] = portEntree

  // 2. décider : si on connaît macDst, envoyer sur SON port ;
  //    sinon, INONDER (envoyer sur tous les ports sauf celui d'entrée) —
  //    c'est le seul cas où le commutateur se comporte comme un hub.
  if (table[macDst] !== undefined) {
    return "port " + table[macDst];          // envoi ciblé
  }
  return "INONDATION (dst inconnue)";        // apprentissage en cours
}

console.log("A -> B (A sur port 1) :", traiter("A", "B", 1));  // B inconnu -> inondation
console.log("B -> A (B sur port 2) :", traiter("B", "A", 2));  // A connu -> ciblé
console.log("A -> B (A sur port 1) :", traiter("A", "B", 1));  // B connu -> ciblé
console.log("table apprise :", JSON.stringify(table));

// ── Partie B : détection d'erreur (esprit du CRC) ───────────────────────────
// À l'émission, on calcule un contrôle sur la trame ; on l'envoie avec. À la
// réception, on recalcule : s'il diffère, la trame a été ALTÉRÉE (bruit,
// chapitre 3) et on la JETTE. Ici, un contrôle simple : parité des bits à 1.
function controle(trame) {
  let uns = 0;
  for (const c of trame) if (c === "1") uns++;
  return uns % 2;                 // 0 si nombre pair de 1, 1 sinon
}

// À VOUS : recevoir() doit renvoyer "OK" ou "ERREUR détectée".
function recevoir(trame, controleRecu) {
  // à compléter : recalculer le contrôle et comparer
  return "?";
}

const trame = "10110100";
const c = controle(trame);
console.log("");
console.log("émission : trame =", trame, " contrôle =", c);
console.log("réception intacte  :", recevoir(trame, c));           // OK
console.log("réception altérée  :", recevoir("10110000", c));      // un bit a changé

Solution

function traiter(macSrc, macDst, portEntree) {
  table[macSrc] = portEntree;                 // APPRENTISSAGE
  if (table[macDst] !== undefined) return "port " + table[macDst];
  return "INONDATION (dst inconnue)";
}
// A -> B : B inconnu -> INONDATION, mais on apprend « A est sur le port 1 ».
// B -> A : A désormais connu -> envoi CIBLÉ sur le port 1 ; on apprend B/port 2.
// A -> B : B connu -> envoi ciblé. La table s'est remplie SEULE, par
// observation du trafic. C'est l'auto-apprentissage du commutateur.

function recevoir(trame, controleRecu) {
  return controle(trame) === controleRecu ? "OK" : "ERREUR détectée";
}
// Trame intacte : contrôle recalculé = contrôle reçu -> OK.
// Trame "10110000" (un 1 devenu 0) : parité changée -> ERREUR détectée, on jette.

// ── Ce que le TP enseigne ───────────────────────────────────────────────────
//
// 1. Le COMMUTATEUR n'est pas un hub. Il apprend, par observation, la
//    correspondance MAC -> port, et n'envoie ensuite qu'au bon port. Il
//    n'inonde que tant qu'il ne connaît pas la destination (et pour les
//    diffusions). D'où : moins de trafic inutile, et les machines ne se
//    disputent plus le médium. C'est ce que « monter en couche 2 » apporte
//    par rapport à la couche 1.
//
// 2. La DÉTECTION D'ERREUR répond au bruit du chapitre 3. On envoie un
//    contrôle calculé sur la trame ; le récepteur le recalcule et compare.
//    S'ils diffèrent, la trame a été altérée : on la JETTE (on ne corrige
//    pas — corriger, ce sera le rôle de TCP au chapitre 7, par
//    retransmission).
//
// 3. Notre parité ne détecte qu'un nombre IMPAIR de bits erronés — deux bits
//    inversés lui échappent. Le vrai CRC (contrôle de redondance cyclique)
//    d'Ethernet est bien plus robuste : il détecte quasiment toutes les
//    erreurs réalistes. Le principe — calculer, envoyer, recalculer,
//    comparer — est exactement le même.

Ce que la suite en fait

Vous savez maintenant faire communiquer des machines sur un même réseau local : trames, adresses MAC, détection d'erreurs, commutateur, ARP. Mais l'adresse MAC est plate et locale — elle ne permet pas de trouver une machine à l'autre bout du monde.

C'est exactement le problème que résout la couche réseau, le cœur du cours. Le chapitre 5 introduit l'adresse IP — une adresse globale et structurée, qui porte une information de localisation — et le découpage en sous-réseaux, l'automatisme de calcul le plus important de l'année. Le couple MAC locale / IP globale, posé ici, en est la clé.

À retenir

Flashcards · 4 cartes

Qu'est-ce qu'une adresse MAC, et pourquoi ne suffit-elle pas à router à travers le monde ?
Un identifiant de 48 bits gravé par le fabricant (ex. a4:83:e7:2c:1f:90), censé unique au monde, qui désigne une carte réseau. Elle est PLATE et LOCALE : elle ne porte aucune information de localisation. On peut donc joindre une machine par sa MAC sur le réseau LOCAL, mais pas la router mondialement — rien dans la MAC ne dit où elle se trouve. D'où le besoin de l'adresse IP (chapitre 5) : MAC = adresse de voisinage, IP = destination globale.
Comment détecte-t-on les erreurs en couche liaison, et détecter équivaut-il à corriger ?
Par un code de contrôle ajouté à la trame : l'émetteur le calcule, le récepteur le recalcule et compare — s'ils diffèrent, la trame est jetée. La parité est faible (rate un nombre pair d'erreurs) ; le CRC (division polynomiale) d'Ethernet est robuste. DÉTECTER n'est PAS corriger : la couche liaison écarte la trame erronée ; la récupération par retransmission relève de TCP (couche transport, chapitre 7).
En quoi un commutateur diffère-t-il d'un concentrateur (hub) ?
Le hub (couche 1) recopie tout sur tous les ports. Le commutateur (couche 2) lit les adresses MAC et n'envoie chaque trame qu'au BON port. Il APPREND tout seul sa table (MAC → port) en observant les trames ; il n'inonde que si la destination est inconnue ou pour une diffusion. Résultat : plus de trafic inutile et plus de collisions. C'est ce que « monter en couche 2 » apporte.
À quoi sert ARP, et quel rôle de charnière joue-t-il ?
ARP traduit une adresse IP (couche 3, globale) en adresse MAC (couche 2, locale), nécessaire pour livrer une trame sur le réseau local. Il diffuse « qui a l'IP X ? » ; la machine concernée répond avec sa MAC, mise en cache. C'est le pont entre le monde IP et le monde MAC. Son absence d'authentification en fait une cible (usurpation ARP), reprise dans le cours de cybersécurité.