Lezione 9 · Canale 2 · lunedì 19 ottobre 2026

Livello di collegamento: framing, duplexing e controllo degli errori

FCI · Reti

Il livello di collegamento

Il livello di collegamento (livello 2) porta un pacchetto lungo un solo collegamento, cioè fra due nodi adiacenti. Il collegamento può essere cablato, wireless o una rete locale. L'unità dati del livello è il frame: su ogni collegamento il pacchetto viaggia in un frame diverso.

Il livello offre al livello di rete quattro servizi:

il framing, cioè la creazione del frame e la sua delimitazione;
il duplexing, cioè l'uso del collegamento nelle due direzioni;
la rivelazione e correzione degli errori;
la consegna affidabile, che recupera perdite, errori binari, duplicati e frame fuori sequenza.

Un protocollo può offrirne solo alcuni: Ethernet rivela gli errori, ma non li corregge e non garantisce la consegna affidabile.

Il livello è realizzato in parte nella scheda di rete (NIC), insieme al livello fisico, e in parte nel software di controllo del sistema operativo, eseguito dalla CPU. È quindi la frontiera fra hardware e software.

Framing e flag

Il framing costruisce il frame incapsulando il pacchetto con un'intestazione di collegamento e una coda (trailer). Il ricevitore però vede solo un flusso di bit, quindi deve riconoscere dove un frame comincia. La lunghezza, un campo di quasi tutte le intestazioni, dice dove finisce il frame solo se si sa già dove comincia.

Per questo ogni frame inizia e termina con una sequenza fissa e riconoscibile, il flag:

\text{flag}\;\;H_l\;\;\text{pacchetto}\;\;\text{coda}\;\;\text{flag}

Un flag possibile è il byte

01111110

Il flag funziona solo se non compare altrove nel frame. I dati però possono contenerlo per caso, e allora il ricevitore sbaglia i confini del frame: lo stuffing lo impedisce.

Bit stuffing

Il bit stuffing inserisce uno $0$ dopo ogni sequenza di cinque $1$ consecutivi nel frame, qualunque sia il bit successivo. Il flag di delimitazione non si modifica.

Dopo lo stuffing i dati non contengono mai sei $1$ consecutivi, mentre il flag ne ha sei, quindi il flag non si può più imitare. Il ricevitore conta i $1$ consecutivi. Dopo cinque $1$ guarda il bit successivo:

se è $1$ , la sequenza è un flag;
se è $0$ , è un bit di stuffing e si elimina (destuffing).

Esempio. Dopo i primi due bit, la sequenza originale ha undici $1$ consecutivi, che ricevono uno $0$ dopo il quinto e uno dopo il decimo. Più avanti ci sono cinque $1$ , poi sei $1$ fra due $0$ , che formerebbero un flag: ognuno dei due gruppi riceve uno $0$ . I quattro $0$ inseriti sono sottolineati:

\begin{aligned} \text{originale}&\quad 10111111111110110111110011111100\\ \text{trasmessa}&\quad 1011111\underline{0}11111\underline{0}1011011111\underline{0}0011111\underline{0}100 \end{aligned}

La sequenza passa da $32$ a $36$ bit. Il destuffing elimina i quattro $0$ e riottiene l'originale.

Byte stuffing

Il byte stuffing, usato dal protocollo PPP, lavora su sequenze di otto bit. Oltre al flag serve un byte di escape (control escape):

\begin{aligned} \text{flag}&=01111110\\ \text{escape}&=01111101 \end{aligned}

In trasmissione, se in una parte del frame compare il flag o l'escape, si antepone un escape. In ricezione:

due escape consecutivi: se ne elimina uno;
un escape seguito da un flag: si elimina l'escape e quel flag è un dato;
un flag solo: è il flag di delimitazione.

Nell'esempio l'escape compare nei dati dopo i primi dodici bit, quindi riceve davanti un secondo escape, sottolineato, e la sequenza passa da $28$ a $36$ bit:

\begin{aligned} \text{originale}&\quad 101111111011\;01111101\;01111100\\ \text{trasmessa}&\quad 101111111011\;\underline{01111101}\;01111101\;01111100 \end{aligned}

Duplexing

Un collegamento porta dati in due direzioni: uplink, dall'utente verso la rete, e downlink, dalla rete verso l'utente.

Half duplex: si trasmette nelle due direzioni, ma una per volta.
Full duplex: le due direzioni sono attive nello stesso momento.

Il servizio dipende dallo standard di livello 2 e non dal mezzo: nelle reti domestiche, per esempio, Ethernet usa la fibra ottica in full duplex. Le direzioni si separano in tre modi:

nello spazio: una coppia di fili per ogni direzione, come nei cavi Ethernet, full duplex;
in frequenza: la banda passante $W$ si divide in due porzioni, come nella DSL;
nel tempo: le direzioni si alternano sul mezzo, come nelle reti ottiche passive (PON).

Nell'ADSL (Asymmetric DSL) la ripartizione è asimmetrica: il downlink riceve più banda, perché gli utenti scaricano più di quanto caricano.

Divisione in frequenza

banda

W

(frequenza)

uplink
downlink

La banda

W

è divisa fra le due direzioni. Nell'ADSL il downlink riceve la porzione più grande; le proporzioni disegnate sono indicative.

Errori di trasmissione

In un modello semplice un $1$ è una tensione positiva e uno $0$ una negativa. Il segnale perde potenza lungo il mezzo (attenuazione) e gli si somma il rumore, un disturbo casuale che non si può eliminare. Il ricevitore usa una soglia: tensione positiva vale $1$ , negativa vale $0$ . Se il rumore porta la tensione dall'altra parte della soglia, il bit è letto male.

Il rapporto segnale-rumore è l'indicatore principale della probabilità di errore binario. Se è alto, il rumore influisce poco: con il segnale ricevuto forte i bit $1\,0\,1\,1$ restano dal lato giusto della soglia. L'attenuazione riduce il segnale ma non il rumore, quindi il rischio di errore cresce.

Bit $1011$ con attenuazione e rumore

t

tensione

tensione trasmessa
tensione ricevuta
soglia di decisione

ampiezza ricevuta0,8

Il rumore resta lo stesso. Abbassando l'ampiezza ricevuta, cioè con più attenuazione, la tensione ricevuta passa dall'altra parte della soglia e il bit viene letto male.

Parole di codice

Il trasmettitore invia una sequenza binaria $M$ e il ricevitore riceve $M'$ , che per il rumore può essere diversa. Per accorgersene il trasmettitore non invia una stringa qualsiasi: usa solo parole di codice (codeword), un vocabolario ristretto di stringhe ammesse.

Se la stringa ricevuta non è una parola di codice, c'è sicuramente un errore.
Se è una parola di codice, non si può concludere che sia corretta: gli errori possono trasformare una parola di codice in un'altra, come «cane» in «pane». Sono gli errori non rivelati.

Un codificatore calcola dalla stringa da proteggere i bit di controllo, che le si aggiungono come ridondanza (overhead). Siano $k$ la lunghezza del blocco da proteggere e $n$ quella della parola di codice. I bit di controllo sono $n-k$ e l'overhead è la loro quota nella parola:

\text{overhead}=\frac{n-k}{n}

Un esempio intuitivo è ripetere dieci volte ogni bit: una stringa ricevuta che non è tutta di $1$ o tutta di $0$ rivela un errore. La maggioranza dei bit suggerisce il valore trasmesso, ma senza certezza. Si cerca di proteggere con meno bit di controllo possibile.

Il ricevitore ripete il calcolo sui bit ricevuti e confronta i bit di controllo calcolati con quelli ricevuti. Le famiglie di codici sono tre: parità singola, parità a blocchi e codici a ridondanza ciclica (CRC).

Parità singola

La parità singola aggiunge un bit a $k$ bit informativi $b_1,\dots,b_k$ , scelto perché il numero di $1$ della parola sia pari:

b_{k+1}=(b_1+b_2+\cdots+b_k)\bmod 2

La parola di codice è $(b_1,\dots,b_k,b_{k+1})$ , quindi $n=k+1$ e l'overhead è

\frac{n-k}{n}=\frac{1}{k+1}

Esempio con $k=7$ e bit $0101100$ . Contiene tre $1$ , quindi $b_8=1$ e la parola è $01011001$ , con quattro $1$ .

Errore nel bit 3: si riceve $01111001$ , con cinque $1$ . Il numero è dispari: non è una parola di codice e l'errore è rivelato.
Errori nei bit 3 e 5: si riceve $01110001$ , con quattro $1$ . È una parola di codice, quindi l'errore non è rivelato.

Ogni bit invertito cambia la parità del numero di $1$ . Dopo un numero dispari di inversioni il numero di $1$ è dispari e l'errore si rivela; dopo un numero pari torna pari e l'errore passa inosservato.

Vettore d'errore

Il messaggio ricevuto $M'$ è quello trasmesso $M$ sommato bit a bit, modulo $2$ , a un vettore d'errore $E$ binario della stessa lunghezza $n$ :

M'=M\oplus E

Il bit $E_i$ vale $1$ dove il bit ricevuto è diverso da quello trasmesso:

E_i=\begin{cases}0&\text{se }M_i=M'_i\\1&\text{se }M_i\ne M'_i\end{cases}

Se si trasmette $M=1010$ e si riceve $M'=1110$ , il secondo bit è sbagliato e $E=0100$ . Nell'esempio della parità gli errori nei bit $3$ e $5$ hanno $E=00101000$ .

Formulario

Frame

\text{flag}\;H_l\;\text{pacchetto}\;\text{coda}\;\text{flag}

Flag e escape

\begin{aligned} \text{flag}&=01111110\\ \text{escape}&=01111101 \end{aligned}

Bit stuffing

11111\to111110

Byte stuffing, nei dati

\begin{aligned} \text{flag}&\to\text{escape}\;\text{flag}\\ \text{escape}&\to\text{escape}\;\text{escape} \end{aligned}

Parole di codice

\begin{aligned} k&:\text{ bit da proteggere}\\ n&:\text{ bit della parola}\\ n-k&:\text{ bit di controllo} \end{aligned}

Overhead

\frac{n-k}{n}

Bit di parità

b_{k+1}=(b_1+\cdots+b_k)\bmod 2

Overhead della parità

\frac{1}{k+1}

Parità: numero di errori

\begin{aligned} \text{dispari}&:\text{ rivelati}\\ \text{pari}&:\text{ non rivelati} \end{aligned}

Vettore d'errore

M'=M\oplus E

E_i=\begin{cases}0&\text{se }M_i=M'_i\\1&\text{se }M_i\ne M'_i\end{cases}