1112 lines
50 KiB
TeX
1112 lines
50 KiB
TeX
\documentclass[a4paper,french,12pt]{article}
|
|
|
|
\title{Communications Numériques}
|
|
\author{}
|
|
\date{Dernière compilation~: \today{} à \currenttime}
|
|
|
|
\usepackage{styles}
|
|
|
|
\pgfmathdeclarefunction{gauss}{2}{%
|
|
\pgfmathparse{1/(#2*sqrt(2*pi))*exp(-((x-#1)^2)/(2*#2^2))}
|
|
}
|
|
|
|
\begin{document}
|
|
|
|
\maketitle
|
|
\tableofcontents
|
|
|
|
\clearpage
|
|
|
|
\section{Introduction}
|
|
|
|
\subsection{Transmission synchrone / asynchrone}
|
|
|
|
\subsubsection{Transmission synchrone}
|
|
|
|
À la réception, l'horloge regénérée définit la cadence.
|
|
Les transitions de l'horloge coïncident avec celle des données constituées d'un flux ininterrompu de bits.
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=1, transform shape]
|
|
\foreach \i in {1,2,3,4,6,7,8,9}{\draw [dashed] (\i,-2.7) -- (\i,0.7);}
|
|
\foreach \i in {0,5,10}{\draw [dashed,very thick] (\i,-3) -- (\i,0.7);}
|
|
\node at (-1.5,0) {\parbox{2cm}{\centering Horloge regénérée}};
|
|
\draw [-latex] (0,0) -- (11,0);
|
|
\node at (-1.5,-2) {\parbox{2cm}{\centering Données synchrones}};
|
|
\draw [-latex] (0,-2) -- (11,-2);
|
|
\foreach \i in {0,1,...,9}{
|
|
\draw [red,very thick] (\i,0.5) -- (\i+0.5,0.5) -- (\i+0.5,0) -- (\i+1,0) -- (\i+1,0.5);
|
|
}
|
|
\draw [red,very thick]
|
|
(0,-2) -- (1,-2) --
|
|
(1,-1.5) -- (3,-1.5) --
|
|
(3,-2) -- (4,-2) --
|
|
(4,-1.5) -- (5,-1.5) --
|
|
(5,-2) -- (7,-2) --
|
|
(7,-1.5) -- (10,-1.5) -- (10,-2)
|
|
;
|
|
\foreach \i in {0,3,5,6}{\node at (\i+0.5,-2.4) {0};}
|
|
\foreach \i in {1,2,4,7,8,9}{\node at (\i+0.5,-2.4) {1};}
|
|
|
|
\node at (2.5,-3) {1\up{er} caractère};
|
|
\node at (7.5,-3) {2\up{ème} caractère};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\subsubsection{Transmission asynchrone}
|
|
|
|
À la réception, l'arrivée des données \emph{démarre} l'horloge.
|
|
La transition initiale d'un paquet de données de longueur déterminée définit la transition initiale de l'horloge.
|
|
À la fin du paquet de données, cette horloge s'interrompt.
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=1, transform shape]
|
|
\node (d) at (-1.5,0.5) {Données};
|
|
\draw (0,1) -- (2,1) -- (2,0) node[currarrow,pos=0.5,sloped] {}
|
|
-- (4,0) -- (4,1) -- (5,1) -- (5,0) -- (6,0) -- (6,1) -- (8,1)
|
|
;
|
|
\draw [dashed] (8,1) -- (9,1);
|
|
\draw (9,1) -- (10,1) -- (10,0) node[currarrow,pos=0.5,sloped] {} -- (11,0);
|
|
|
|
\node (h) at (-1.5,-1.25) {Horloge};
|
|
\draw (0,-1.5) -- (2,-1.5) -- (2,-1) node[currarrow,pos=0.5,sloped] {};
|
|
\foreach \i in {2,3,...,6}{
|
|
\draw (\i,-1) -- (\i+0.5,-1) -- (\i+0.5,-1.5) -- (\i+1,-1.5);
|
|
}
|
|
\foreach \i in {3,4,5,6}{
|
|
\draw (\i,-1.5) -- (\i,-1);
|
|
}
|
|
\draw (7,-1.5) -- (8,-1.5);
|
|
\draw [dashed] (8,-1.5) -- (9,-1.5);
|
|
\draw (9,-1.5) -- (10,-1.5) -- (10,-1) node[currarrow,pos=0.5,sloped] {};
|
|
\foreach \i in {10,11}{
|
|
\draw (\i,-1) -- (\i+0.5,-1) -- (\i+0.5,-1.5) -- (\i+1,-1.5);
|
|
}
|
|
\draw (11,-1.5) -- (11,-1);
|
|
\path
|
|
(1.8,0.5) edge [->,>=latex,bend right] (1.8,-1.25)
|
|
(9.8,0.5) edge [->,>=latex,bend right] (9.8,-1.25)
|
|
;
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Pour ``réveiller'' le récepteur, l'émetteur émet une trame de \emph{wake up}.
|
|
En effet, le récepteur, pour économiser des resources, écoute de temps en temps.
|
|
|
|
À la réception d'une trame de \emph{wake up}, elle doit se mettre en place, ce qui peut prendre du temps.
|
|
Elle reçoit donc une trame \emph{sync word}, après laquelle elle s'attend à recevoir le premier bit de charge utile (\emph{payload}).
|
|
|
|
Même à fréquence identique, l'horloge d'émission (période de $T$) et l'horloge à la réception (période de $T + \Delta T$) ne sont jamais complètement identiques.
|
|
|
|
Ce décalage s'accumule au fil du temps, ce qui est gênant.
|
|
Quand on échantillonne les bits reçus, on va avoir deux cas~:
|
|
|
|
\begin{enumerate}
|
|
\item $\Delta T > 0$~: on va perdre des bits à l'échantillonnage.
|
|
\item $\Delta T < 0$~: on va échantillonner plusieurs fois le même bit.
|
|
\end{enumerate}
|
|
|
|
Si on envoie peu de bits (8 bits $< \Delta T$), ce problème est négligeable.
|
|
Il faut donc synchroniser les horloges tous les 8 bits.
|
|
|
|
\section{Structure générale d'une chaîne de transmission numérique}
|
|
|
|
\subsection{Système de transmission en bande de base (\emph{base band})}
|
|
|
|
Le signal est directement transmis sur le canal de transmission.
|
|
Son spectre est centré sur la fréquence 0.
|
|
Les câbles sont les canaux de transmission possibles (paire torsadée, câble coaxial, paire avec écran\ldots).
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.8, transform shape]
|
|
\node [ellipse,draw] (source) at (0,0) {Source};
|
|
|
|
\node [rectangle,fill=olive!40] at (4.5,1.5) {Codage de source};
|
|
\node [rectangle,fill=olive!40,minimum width=5.5cm,minimum height=1.7cm] at (4.5,0) {};
|
|
\node [rectangle,draw,fill=white,minimum width=1.5cm] (c) at (3,0) [label=below:Chiffrement] {C};
|
|
\node [rectangle,draw,fill=white,minimum width=1.5cm] (r) at (6,0) [label=below:Compression] {R};
|
|
|
|
\node [rectangle,fill=blue!30] at (12,1.5) {Codage du canal};
|
|
\node [rectangle,fill=blue!30,minimum width=8.5cm,minimum height=1.7cm] at (12,0) {};
|
|
\node [rectangle,draw,fill=white,minimum width=1.5cm] (e) at (9,0) [label=below:\parbox{2cm}{\centering Encodage\\Détecteur\\Correcteur\\d'erreurs}] {E};
|
|
\node [rectangle,draw,fill=white,minimum width=1.5cm] (b) at (12,0) [label=below:Embrouillage] {B};
|
|
\node [rectangle,draw,fill=white,minimum width=1.5cm] (v) at (15,0) [label=right:\parbox{2cm}{Codage\\numérique}] {V};
|
|
|
|
\node [diamond,draw] (canal) at (15,-3) {canal};
|
|
\node [diamond,draw] (h1) at (13,-5.5) [label=left:Regénération] {H--1};
|
|
|
|
\node [rectangle,draw,minimum width=1.5cm] (v1) at (15,-8) [label=right:\parbox{2cm}{Décodage\\numérique}] {V--1};
|
|
\node [rectangle,draw,minimum width=1.5cm] (b1) at (12,-8) [label=below:Désembrouillage] {B--1};
|
|
\node [rectangle,draw,minimum width=1.5cm] (e1) at (9,-8) [label=below:\parbox{2cm}{\centering Détection et Correction des erreurs}] {E--1};
|
|
\node [rectangle,draw,minimum width=1.5cm] (r1) at (6,-8) [label=below:Décompression] {R--1};
|
|
\node [rectangle,draw,minimum width=1.5cm] (c1) at (3,-8) [label=below:Déchiffrement] {C--1};
|
|
\node [ellipse,draw] (utilisation) at (-1,-8) {Utilisation};
|
|
|
|
\draw [-latex] (source) -- (c) node[above, midway]{$\{sk\}$};
|
|
\draw [-latex] (c) -- (r) node[above, midway]{$\{dk\}$};
|
|
\draw [-latex] (r) -- (e) node[above, midway]{$\{ck\}$};
|
|
\draw [-latex] (e) -- (b) node[above, midway]{$\{bk\}$};
|
|
\draw [-latex] (b) -- (v) node[above, midway]{$\{\alpha k\}$};
|
|
|
|
\draw [-latex] (v) -- (canal) node[right, midway]{$e(t)$};
|
|
\draw [-latex] (canal) -- (v1) node[right, midway]{$r(t)$};
|
|
|
|
\draw [-latex] (15,-4.2) -- (13,-4.2) -- (h1);
|
|
\draw [-latex] (h1) -- (13,-7) -- (-1,-7) -- (utilisation);
|
|
\draw [-latex] (13,-7) -- (14.3,-7) -- (v1);
|
|
\draw [-latex] (12,-7) -- (b1);
|
|
\draw [-latex] (9,-7) -- (e1);
|
|
\draw [-latex] (6,-7) -- (r1);
|
|
\draw [-latex] (3,-7) -- (c1);
|
|
|
|
\draw [-latex] (v1) -- (b1) node[above, midway]{\{$\alpha k_e$\}};
|
|
\draw [-latex] (b1) -- (e1) node[above, midway]{$\{bk_e\}$};
|
|
\draw [-latex] (e1) -- (r1) node[above, midway]{$\{ck_e\}$};
|
|
\draw [-latex] (r1) -- (c1) node[above, midway]{$\{dk_e\}$};
|
|
\draw [-latex] (c1) -- (utilisation) node[above, midway]{$\{sk_e\}$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\subsection{Système de transmission en bande transposée (\emph{broad band})}
|
|
|
|
Le signal est modulé avant d'être transmis sur le canal de transmission.
|
|
Son spectre est centré sur la fréquence porteuse.
|
|
Les canaux de transmission possibles sont~:
|
|
\begin{itemize}
|
|
\item câbles
|
|
\item transmission hertzienne sans fil en espace libre
|
|
\item transmission optique en espace libre (infra rouge)
|
|
\item transmission optique guidée (fibre optique)
|
|
\end{itemize}
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.8, transform shape]
|
|
\node [ellipse,draw] (source) at (0,0) {Source};
|
|
|
|
\node [rectangle,fill=olive!40] at (4.5,1.5) {Codage de source};
|
|
\node [rectangle,fill=olive!40,minimum width=5.5cm,minimum height=1.7cm] at (4.5,0) {};
|
|
\node [rectangle,draw,fill=white,minimum width=1.5cm] (c) at (3,0) [label=below:Chiffrement] {C};
|
|
\node [rectangle,draw,fill=white,minimum width=1.5cm] (r) at (6,0) [label=below:Compression] {R};
|
|
|
|
\node [rectangle,fill=blue!30] at (12,1.5) {Codage du canal};
|
|
\node [rectangle,fill=blue!30,minimum width=8.5cm,minimum height=1.7cm] at (12,0) {};
|
|
\node [rectangle,draw,fill=white,minimum width=1.5cm] (e) at (9,0) [label=below:\parbox{2cm}{\centering Encodage\\Détecteur\\Correcteur\\d'erreurs}] {E};
|
|
\node [rectangle,draw,fill=white,minimum width=1.5cm] (b) at (12,0) [label=below:Embrouillage] {B};
|
|
\node [rectangle,draw,fill=white,minimum width=1.5cm] (v) at (15,0) [label=right:\parbox{2cm}{Codage\\numérique}] {V};
|
|
|
|
\node [rectangle,red,draw,minimum width=1.5cm] [label={[text=red]left:\parbox{2cm}{\centering Modulation\\numérique}},label={[text=red]right:$x(t)$}] (l) at (15,-2.5) {L};
|
|
\node [diamond,draw] (canal) at (15,-5) {canal};
|
|
\node [rectangle,red,draw,minimum width=1.5cm] [label={[text=red]left:\parbox{2.5cm}{\centering Démodulation\\numérique}},label={[text=red]right:$x(t)_e$}] (l1) at (15,-7.5) {L--1};
|
|
\node [diamond,draw] (h1) at (13,-9.5) [label=left:Regénération] {H--1};
|
|
|
|
\node [rectangle,draw,minimum width=1.5cm] (v1) at (15,-12) [label=right:\parbox{2cm}{Décodage\\numérique}] {V--1};
|
|
\node [rectangle,draw,minimum width=1.5cm] (b1) at (12,-12) [label=below:Désembrouillage] {B--1};
|
|
\node [rectangle,draw,minimum width=1.5cm] (e1) at (9,-12) [label=below:\parbox{2cm}{\centering Détection et Correction des erreurs}] {E--1};
|
|
\node [rectangle,draw,minimum width=1.5cm] (r1) at (6,-12) [label=below:Décompression] {R--1};
|
|
\node [rectangle,draw,minimum width=1.5cm] (c1) at (3,-12) [label=below:Déchiffrement] {C--1};
|
|
\node [ellipse,draw] (utilisation) at (-1,-12) {Utilisation};
|
|
|
|
\draw [-latex] (source) -- (c) node[above, midway]{$\{sk\}$};
|
|
\draw [-latex] (c) -- (r) node[above, midway]{$\{dk\}$};
|
|
\draw [-latex] (r) -- (e) node[above, midway]{$\{ck\}$};
|
|
\draw [-latex] (e) -- (b) node[above, midway]{$\{bk\}$};
|
|
\draw [-latex] (b) -- (v) node[above, midway]{$\{\alpha k\}$};
|
|
|
|
\draw [-latex] (v) -- (l);
|
|
\draw [-latex] (l) -- (canal) node[right, midway]{$e(t)$};
|
|
\draw [-latex] (canal) -- (l1) node[right, midway]{$r(t)$};
|
|
\draw [-latex] (l1) -- (v1);
|
|
|
|
\draw [-latex] (15,-8.2) -- (13,-8.2) -- (h1);
|
|
\draw [-latex] (h1) -- (13,-11) -- (-1,-11) -- (utilisation);
|
|
\draw [-latex] (13,-11) -- (14.3,-11) -- (v1);
|
|
\draw [-latex] (12,-11) -- (b1);
|
|
\draw [-latex] (9,-11) -- (e1);
|
|
\draw [-latex] (6,-11) -- (r1);
|
|
\draw [-latex] (3,-11) -- (c1);
|
|
|
|
\draw [-latex] (v1) -- (b1) node[above, midway]{\{$\alpha k_e$\}};
|
|
\draw [-latex] (b1) -- (e1) node[above, midway]{$\{bk_e\}$};
|
|
\draw [-latex] (e1) -- (r1) node[above, midway]{$\{ck_e\}$};
|
|
\draw [-latex] (r1) -- (c1) node[above, midway]{$\{dk_e\}$};
|
|
\draw [-latex] (c1) -- (utilisation) node[above, midway]{$\{sk_e\}$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\subsection{Canal de transmission}
|
|
|
|
Il est toujours supposé linéaire, modélisable par un filtre linéaire invariable dans le temps.
|
|
Il amène des perturbations d'origines diverses (bruit thermique, diaphonie entre canaux\ldots).
|
|
|
|
Ce défaut est modélisé par une source de bruit additif, avec une loi de probabilité gaussienne et une densité spectrale de puissance constante (\emph{bruit blanc gaussien}).
|
|
On parle ainsi de \emph{canal à bruit blanc additif} (AWGN, Additive White Gaussian Noise).
|
|
|
|
\subsection{Intérêt de la transmission numérique}
|
|
|
|
Le passage du signal dans un canal qui est déformant (filtrage) et bruyant est un problème de la transmission analogique.
|
|
|
|
\begin{equation*}
|
|
r(t) = (e(t) + n(t)) * h(t)
|
|
\end{equation*}
|
|
|
|
\begin{itemize}
|
|
\item $n(t)$ est le bruit blanc gaussien.
|
|
\item $h(t)$ est la réponse impulsionnelle du filtre caractérisant le canal de transmission.
|
|
\end{itemize}
|
|
|
|
En général, il est impossible de retrouver $e(t)$ à partir de $r(t)$.
|
|
Il faut que $e(t)$ possède des propriétés particulières connues et invariantes dans le temps pour espérer estimer $e(t)$ à partir de $r(t)$.
|
|
|
|
Un signal numérique possède ces propriétés~: seulement un nombre fini de valeurs possibles et des changements de valeurs tous les $nT$.
|
|
Il est alors beaucoup plus simple de regénérer le signal émis d'après le signal reçu.
|
|
|
|
\paragraph{Méthode d'estimation}
|
|
|
|
\begin{enumerate}
|
|
\item repérer les transitions du signal
|
|
\item à partir de ces transitions, regénérer un signal d'horloge
|
|
\item grâce à cette horloge, venir échantillonner à un instant choisi la valeur du signal reçu
|
|
\item comparer cette valeur échantillonnée aux valeurs possibles et attribuer une de ces valeurs
|
|
\item reconstruire le signal numérique grâce à l'ensemble des valeurs retrouvées et à l'horloge
|
|
\end{enumerate}
|
|
|
|
Avec une transmission numérique, on peut donc~:
|
|
|
|
\begin{itemize}
|
|
\item regénérer le signal (donc l'information) après chaque transmission, alors qu'un signal analogique ne peut que se dégrader
|
|
\item mettre en \oe{}uvre un système de codage et de détection et correction des erreurs
|
|
\item envisager des techniques de cryptage et de compression
|
|
\item coder de la même manière tout type d'information (voix, vidéo, texte)
|
|
\end{itemize}
|
|
|
|
\subsection{Définitions}
|
|
|
|
\paragraph{Débit brut (rate)~: $D$}
|
|
|
|
\begin{itemize}
|
|
\item nombre de symboles émis pendant l'unité de temps
|
|
\item coïncide avec la fréquence d'horloge
|
|
\item si les symboles sont binaires, on parle de \emph{débit binaire brut} (bit rate) et l'unité est le bit/s
|
|
\end{itemize}
|
|
|
|
\paragraph{Débit moyen, statistique ou entropique (average, statistic, or entropic rate)}
|
|
|
|
Valeur de l'entropie de la source par unité de temps.
|
|
|
|
\begin{equation*}
|
|
H_m = \sum p_i \log_m\left(\frac{1}{p_i}\right)
|
|
\end{equation*}
|
|
|
|
\ldots{} pour des symboles appartenant à un alphabet de source à $m$ éléments.
|
|
|
|
\paragraph{Rapidité de modulation (baud rate)~: $R$}
|
|
|
|
C'est l'inverse du temps entre deux transitions du signal qui circule sur la ligne de transmission.
|
|
|
|
\begin{itemize}
|
|
\item transition de niveau (bande de base)
|
|
\item transition d'amplitude, de fréquence ou de phase (bande transposée)
|
|
\item l'unité est le BAUD
|
|
\end{itemize}
|
|
|
|
\paragraph{Valence}
|
|
|
|
\begin{itemize}
|
|
\item nombre $V$ (parfois $M$) d'états significatifs du signal numérique
|
|
\item états~:
|
|
\begin{itemize}
|
|
\item valeur constante (bande de base)
|
|
\item amplitude, fréquence, ou phase (bande transposée)
|
|
\end{itemize}
|
|
\item cas où le signal numérique a des caractéristiques constantes durant toute la durée de l'état (même valeur, même amplitude, fréquence ou phase)
|
|
\end{itemize}
|
|
|
|
\begin{equation*}
|
|
R = \frac{D}{\log_2(V)}
|
|
\end{equation*}
|
|
|
|
\begin{itemize}
|
|
\item $R$ est la rapidité de modulation en baud
|
|
\item $D$ est le débit brut en bit/s
|
|
\item $V$ est la valence
|
|
\end{itemize}
|
|
|
|
Pour comprendre intuitivement la formule, pour $V=2^n$, \quad $R = \frac{D}{\log_2(2^n)} = \frac{D}{n}$.
|
|
|
|
\begin{itemize}
|
|
|
|
\item Cas où $n=1$~: \\
|
|
|
|
$V=2$ \quad
|
|
\begin{tikzpicture}[scale=0.5, transform shape]
|
|
\foreach \i in {0,2}{
|
|
\draw (\i,0) -- (\i+1,0) -- (\i+1,1) -- (\i+2,1) -- (\i+2,0);
|
|
}
|
|
\draw (4,0) -- (6,0);
|
|
\node at (0.5,1.5) {\LARGE 0};
|
|
\node at (1.5,1.5) {\LARGE 1};
|
|
\node at (2.5,1.5) {\LARGE 0};
|
|
\node at (3.5,1.5) {\LARGE 1};
|
|
\node at (4.5,1.5) {\LARGE 0};
|
|
\node at (5.5,1.5) {\LARGE 0};
|
|
\end{tikzpicture}
|
|
\quad $R=D$ \\
|
|
|
|
\item Cas où $n=2$~:
|
|
|
|
$V=4$ \quad
|
|
\begin{tikzpicture}[scale=0.5, transform shape]
|
|
\draw (0,0) -- (2,0)
|
|
-- (2,1) -- (4,1)
|
|
-- (4,2) -- (6,2)
|
|
-- (6,3) -- (8,3)
|
|
;
|
|
\node at (1,0.5) {\LARGE 0 0};
|
|
\node at (3,1.5) {\LARGE 0 1};
|
|
\node at (5,2.5) {\LARGE 1 0};
|
|
\node at (7,3.5) {\LARGE 1 1};
|
|
\end{tikzpicture}
|
|
\quad $R=\frac{D}{2}$ \\
|
|
|
|
\item Cas où $n=3$~:
|
|
|
|
$V=8$ \quad
|
|
\begin{tikzpicture}[scale=0.5, transform shape]
|
|
\draw (0,0) -- (2,0)
|
|
-- (2,1) -- (4,1)
|
|
-- (4,2) -- (6,2)
|
|
-- (6,3) -- (8,3)
|
|
-- (8,4) -- (10,4)
|
|
-- (10,5) -- (12,5)
|
|
-- (12,6) -- (14,6)
|
|
-- (14,7) -- (16,7)
|
|
;
|
|
\node at (1,0.5) {\LARGE 0 0 0};
|
|
\node at (3,1.5) {\LARGE 0 0 1};
|
|
\node at (5,2.5) {\LARGE 0 1 0};
|
|
\node at (7,3.5) {\LARGE 0 1 1};
|
|
\node at (9,4.5) {\LARGE 1 0 0};
|
|
\node at (11,5.5) {\LARGE 1 0 1};
|
|
\node at (13,6.5) {\LARGE 1 1 0};
|
|
\node at (15,7.5) {\LARGE 1 1 1};
|
|
\end{tikzpicture}
|
|
\quad $R=\frac{D}{3}$ \\
|
|
|
|
\end{itemize}
|
|
|
|
\paragraph{Polarité (polarity)}
|
|
|
|
\begin{itemize}
|
|
\item définition pour les signaux numériques non modulés
|
|
\item signal unipolaire~: toutes les valeurs sont soit positives ou nulles, soit négatives ou nulles
|
|
\item signal antipolaire~: valeurs symétriques deux à deux par rapport à 0, mais sans la valeur 0
|
|
\item signal bipolaire~: antipolaire avec la valeur 0
|
|
\end{itemize}
|
|
|
|
\section{Expressions temporelle et spectrale}
|
|
|
|
\subsection{Expression temporelle}
|
|
|
|
Un signal $x(t)$ correspond à la suite $\{a_k\}$.
|
|
|
|
\begin{equation*}
|
|
x(t) = \sum_k x_k(t)
|
|
\end{equation*}
|
|
|
|
Le signal $x_k(t)$ correspond donc à $a_k$.
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=1, transform shape]
|
|
\node [rectangle,draw,minimum height=0.8cm,minimum width=2cm] (lcodeur) at (-7.5,0) {codeur};
|
|
\draw [latex-] (lcodeur) -- ++(-2cm,0) node[above]{$\{\alpha_k\}$};
|
|
\draw [-latex] (lcodeur) -- ++(2cm,0) node[above]{$x(t)$};
|
|
\node [rectangle,draw] (rcodeur) at (0,0.3) {\parbox{5.5cm}{\centering codeur \vspace{1.7cm}}};
|
|
\node [rectangle,draw,minimum height=0.8cm,minimum width=2cm] (white) at (-1.5,0) {};
|
|
\node [rectangle,draw,minimum height=0.8cm,minimum width=2cm] (g) at (1.5,0) {$g(t)$};
|
|
\draw [latex-] (white) -- ++(-2cm,0) node[above]{$\{\alpha_k\}$};
|
|
\draw [-latex] (white) -- (g) node[above,midway]{$\{a_k\}$};
|
|
\draw [-latex] (g) -- ++(2cm,0) node[above]{$x(t)$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Le symbole $a_k$ n'existe que durant un temps $T$, $\frac{1}{T}$ étant le débit brut de la source.
|
|
|
|
La suite $\{a_k\}$ est alors une suite de valeurs discrètes apparaissant tous les $T$ et à qui on peut associer un signal $a(t)$ grâce au \emph{peigne de Dirac}.
|
|
|
|
\begin{equation*}
|
|
\Sh\left(\frac{t}{T}\right) = \sum_{k=-\infty}^{+\infty} \delta(t - kT)
|
|
\quad\quad\quad\quad
|
|
a(t) = \sum_{k=-\infty}^{+\infty} a_k\,\delta(t - kT)
|
|
\end{equation*}
|
|
|
|
Le codeur est un système linéaire supposé invariant dans le temps.
|
|
La modélisation se fait par sa réponse impulsionnelle $g(t)$ que l'on nomme \emph{formant}.
|
|
\begin{align*}
|
|
x(t) &= g(t) * a(t) \\
|
|
&= g(t) * \sum_{k=-\infty}^{+\infty} a_k\,\delta(t-kT) \\
|
|
&= \sum_{k=-\infty}^{+\infty} a_k\,g(t-kT)
|
|
\end{align*}
|
|
|
|
\subsection{Expression spectrale}
|
|
|
|
\paragraph{Formule de Bennett}
|
|
|
|
\begin{equation*}
|
|
S_{xx}(f) = S_{gg}(f) \left[
|
|
\frac{\sigma_a^2}{T} + \frac{\overline{a}^2}{T^2} \; \Sh\left(\frac{f}{1/T}\right)
|
|
+ \frac{2}{T} \sum_{n=1}^{+\infty} (R_{aa}(n) - \overline{a}^2)\cos(2\pi nfT)
|
|
\right]
|
|
\end{equation*}
|
|
|
|
\begin{itemize}
|
|
|
|
\item Densité Spectrale de Puissance (DSP) de $x(t)$~:
|
|
\begin{equation*}
|
|
S_{xx}(f) = \mathrm{TF}(R_{xx}(\tau))
|
|
\end{equation*}
|
|
|
|
\item Valeur moyenne de la suite $\{a_k\}$~:
|
|
\begin{equation*}
|
|
\overline{a} = E(a_k)
|
|
\end{equation*}
|
|
|
|
\item Variance~:
|
|
\begin{equation*}
|
|
\sigma_a^2 = \mathrm{var}(a) = E(a_k^2) - \overline{a}^2
|
|
\end{equation*}
|
|
|
|
\item Coefficient d'autocorrélation statistique~:
|
|
\begin{equation*}
|
|
R_{aa}(n) = E(a_k\cdot a_{k+n})
|
|
\end{equation*}
|
|
|
|
\item $S_{gg}(f)$~: DSP du formant $g(t)$
|
|
|
|
\end{itemize}
|
|
|
|
On peut simplifier la formule de Bennett dans le cas d'une source sans mémoire~:
|
|
\begin{equation*}
|
|
S_{xx}(f) = S_{gg}(f) \left[
|
|
\frac{\sigma_a^2}{T} + \frac{\overline{a}^2}{T^2} \; \Sh\left(\frac{f}{1/T}\right)
|
|
\right]
|
|
\end{equation*}
|
|
|
|
Le deuxième terme de la formule marque le rythme, grâce au peigne qui représente les \emph{raies spectrales} de l'horloge.
|
|
|
|
\section{Transmission en bande de base~: les codes en ligne}
|
|
|
|
\subsection{Propriétés requises}
|
|
|
|
\begin{enumerate}[label=\alph*]
|
|
|
|
\item \textbf{Le spectre ne doit pas avoir de composante continue\label{itm:prop-a}}
|
|
|
|
Cela implique que la valeur moyenne du signal soit nulle.
|
|
Cette valeur moyenne est de toute façon éliminée par un éventuel condensateur série ou transformateur en cascade qui serait présent sur le système de traitement du canal de transmission.
|
|
|
|
\item \textbf{Le spectre doit être décroissant et tendre vers 0 aux basses fréquences\label{itm:prop-b}}
|
|
|
|
Cette propriété complète la précédente.
|
|
Grâce à elle, un filtre passe-haut, qui coupe les basses fréquences, n'aura que peu d'incidence sur la perte d'information du signal.
|
|
|
|
\item \textbf{Le spectre doit avoir un support le plus étroit possible\label{itm:prop-c}}
|
|
|
|
En plus d'une fréquence de coupure basse, tout système de traitement possède une fréquence de coupure haute, au delà de laquelle il ne fonctionne plus correctement.
|
|
Ce système de traitement se comporte donc comme un filtre passe-bande.
|
|
|
|
\item \textbf{Le spectre doit comprendre des raies à la fréquence d'horloge et à ses multiples\label{itm:prop-d}}
|
|
|
|
Le signal numérique $x(t)$ possédera ainsi implicitement le signal d'horloge.
|
|
|
|
\item \textbf{Le rythme d'horloge doit pouvoir être conservé à court terme\label{itm:prop-e}}
|
|
|
|
La propriété précédente implique que la DSP contienne la fonction peigne (les raies d'horloge).
|
|
Cette DSP résulte d'une Transformée de Fourier, donc d'une moyenne sur le temps.
|
|
Le système de récupération d'horloge, qui fonctionne en temps réel, n'est pas garanti de fournir un signal d'horloge synchrone avec les données.
|
|
|
|
\item \textbf{Le spectre instantané doit être proche du spectre théorique\label{itm:prop-f}}
|
|
|
|
Les propriétés vues précédemment sont vérifiées sur la DSP de $x(t)$ ($S_{xx}(f)$), mais le traitement du signal est fait en temps réel.
|
|
Il faut donc à chaque instant que le spectre instantané (affiché par les analyseurs de spectre) vérifie donc aussi ces propriétés.
|
|
|
|
\begin{equation*}
|
|
X(f,t_0,\Delta t) = \int_{t_0}^{t_0 + \Delta t} x(t) e^{-2\pi jft} \dif t
|
|
\end{equation*}
|
|
|
|
Cela revient donc à vérifier que $X(f,t_0,t) \cong X(f)$ pour tout $t_0$ à $\Delta t$ donné.
|
|
|
|
\begin{equation*}
|
|
X(f) = \int_{-\infty}^{+\infty} x(t) e^{-2\pi jft} \dif t
|
|
\end{equation*}
|
|
|
|
\item \textbf{Le signal doit posséder une redondance de manière à pouvoir tester sa vraisemblance\label{itm:prop-g}}
|
|
|
|
Pour s'assurer à la réception que le signal reçu est \emph{vraisemblable}, il faut faire une simple détection de défaut, au lieu de remplacer le système de détection/correction d'erreurs, qui est beaucoup plus performant et basé sur la vraisemblance du message, non pas du signal.
|
|
|
|
\end{enumerate}
|
|
|
|
\subsection{Codes de voie bivalents}
|
|
|
|
\subsubsection{Code NRZ (Non Return to Zero)}
|
|
|
|
C'est un code \emph{antipolaire} où pendant $T$, \(
|
|
\left\{
|
|
\begin{array}{l}
|
|
0 \rightarrow -V \\
|
|
1 \rightarrow +V \\
|
|
\end{array}
|
|
\right.
|
|
\) donc \(
|
|
\left\{
|
|
\begin{array}{l}
|
|
a_k = -1 \text{ si } \alpha_k = 0 \\
|
|
a_k = +1 \text{ si } \alpha_k = 1 \\
|
|
\end{array}
|
|
\right.
|
|
\)
|
|
|
|
\begin{multicols}{2}
|
|
|
|
La propriété~\ref{itm:prop-a} est respectée. \\
|
|
Ici, $R=D=\frac{1}{T}$.
|
|
|
|
\columnbreak
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=1, transform shape]
|
|
\draw[-latex] (0,0) -- (5,0) node[right]{$t$};
|
|
\node at (0.5,1) {0};
|
|
\node at (1.5,1) {1};
|
|
\node at (2.5,1) {1};
|
|
\node at (3.5,1) {0};
|
|
\node at (4.5,1) {0};
|
|
\foreach \i in {0,1,...,5}{
|
|
\draw[dashed] (\i,-1) -- (\i,1);
|
|
}
|
|
\draw[red,thick] (0,-0.5) -- (1,-0.5) -- (1,0.5) -- (3,0.5) -- (3,-0.5) -- (5,-0.5);
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\end{multicols}
|
|
|
|
\subsubsection{Code NRZI (Non Return to Zero Inverted)}
|
|
|
|
C'est un code \emph{antipolaire} où \(
|
|
\left\{
|
|
\begin{array}{l}
|
|
0 \rightarrow \text{niveau inchangé} \\
|
|
1 \rightarrow \text{transition en } \frac{T}{2} \\
|
|
\end{array}
|
|
\right.
|
|
\)
|
|
|
|
\begin{multicols}{2}
|
|
|
|
Les propriétés~\ref{itm:prop-a} et~\ref{itm:prop-b} sont respectées. \\
|
|
Ici, $R=D=\frac{1}{T}$. \\
|
|
La propriété~\ref{itm:prop-b} est vérifiée à condition que $P(0)=P(1)$ et qu'il n'y a pas de très longue suite de 0.
|
|
|
|
\columnbreak
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=1, transform shape]
|
|
\draw[-latex] (0,0) -- (5,0) node[right]{$t$};
|
|
\node at (0.5,1) {0};
|
|
\node at (1.5,1) {1};
|
|
\node at (2.5,1) {1};
|
|
\node at (3.5,1) {0};
|
|
\node at (4.5,1) {0};
|
|
\foreach \i in {0,1,...,5}{
|
|
\draw[dashed] (\i,-1) -- (\i,1);
|
|
}
|
|
\draw[red,thick] (0,0.5) -- (1.5,0.5) -- (1.5,-0.5) -- (2.5,-0.5) -- (2.5,0.5) -- (5,0.5);
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\end{multicols}
|
|
|
|
\subsubsection{Code RZ (Return to Zero)}
|
|
|
|
C'est un code \emph{unipolaire} où \(
|
|
\left\{
|
|
\begin{array}{l}
|
|
0 \rightarrow 0 \\
|
|
1 \rightarrow H \\
|
|
\end{array}
|
|
\right.
|
|
\) donc \(
|
|
\left\{
|
|
\begin{array}{l}
|
|
a_k = 0 \text{ si } \alpha_k = 0 \\
|
|
a_k = +1 \text{ si } \alpha_k = 1 \\
|
|
\end{array}
|
|
\right.
|
|
\) où $H$ est le signal d'horloge.
|
|
|
|
\begin{multicols}{2}
|
|
|
|
Les propriétés~\ref{itm:prop-d} et~\ref{itm:prop-e} sont respectées. \\
|
|
Ici, $R=2D=\frac{2}{T}$. \\
|
|
La propriété~\ref{itm:prop-e} est vérifiée à condition que $P(1)>P(0)$.
|
|
Ce signal est auto-porteur de son horloge~: c'est un codage destiné à assurer une bonne restitution d'horloge.
|
|
|
|
\columnbreak
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=1, transform shape]
|
|
\draw[-latex] (0,0) -- (5,0) node[right]{$t$};
|
|
\node at (0.5,1) {0};
|
|
\node at (1.5,1) {1};
|
|
\node at (2.5,1) {1};
|
|
\node at (3.5,1) {0};
|
|
\node at (4.5,1) {0};
|
|
\foreach \i in {0,1,...,5}{
|
|
\draw[dashed] (\i,-0.4) -- (\i,1);
|
|
}
|
|
\draw[red,thick] (0,0) -- (1,0) -- (1,0.5) -- (1.5, 0.5) -- (1.5,0) -- (2,0) -- (2,0.5) -- (2.5,0.5) -- (2.5,0) -- (5,0);
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\end{multicols}
|
|
|
|
\subsubsection{Code biphase (Manchester)}
|
|
|
|
C'est un code \emph{antipolaire} avec une horloge $H$ antipolaire~: \(
|
|
\left\{
|
|
\begin{array}{l}
|
|
0 \rightarrow \overline{H} \; (\text{front montant à } \frac{T}{2}) \\
|
|
1 \rightarrow H \; (\text{front descendant à } \frac{T}{2}) \\
|
|
\end{array}
|
|
\right.
|
|
\)
|
|
|
|
\begin{multicols}{2}
|
|
|
|
Les propriétés~\ref{itm:prop-a},~\ref{itm:prop-b} et~\ref{itm:prop-f} sont respectées. \\
|
|
Ici, $R=2D=\frac{2}{T}$. \\
|
|
Ce codage est essentiellement destiné à la transmission aux basses fréquences, au détriment de l'occupation spectrale.
|
|
|
|
\columnbreak
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=1, transform shape]
|
|
\draw[-latex] (0,0) -- (5,0) node[right]{$t$};
|
|
\node at (0.5,1) {0};
|
|
\node at (1.5,1) {1};
|
|
\node at (2.5,1) {1};
|
|
\node at (3.5,1) {0};
|
|
\node at (4.5,1) {0};
|
|
\foreach \i in {0,1,...,5}{
|
|
\draw[dashed] (\i,-1) -- (\i,1);
|
|
}
|
|
\draw[red,thick]
|
|
(0,-0.5) -- (0.5,-0.5) --
|
|
(0.5,0.5) node[color=red,currarrow,midway,sloped] {} --
|
|
(1.5,0.5) --
|
|
(1.5,-0.5) node[color=red,currarrow,midway,sloped] {} --
|
|
(2,-0.5) -- (2,0.5) -- (2.5,0.5) --
|
|
(2.5,-0.5) node[color=red,currarrow,midway,sloped] {} --
|
|
(3.5,-0.5) --
|
|
(3.5,0.5) node[color=red,currarrow,midway,sloped] {} --
|
|
(4,0.5) -- (4,-0.5) -- (4.5,-0.5) --
|
|
(4.5,0.5) node[color=red,currarrow,midway,sloped] {} -- (5,0.5);
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\end{multicols}
|
|
|
|
\subsubsection{Codes FM (Frequency Modulation), dits codes de Miller}
|
|
|
|
\paragraph{Code FM}
|
|
\begin{equation*}
|
|
\left\{
|
|
\begin{array}{l}
|
|
0 \rightarrow \text{ une seule transition initiale (début de symbole) } \\
|
|
1 \rightarrow \text{ une transition initiale et une transition à } \frac{T}{2} \\
|
|
\end{array}
|
|
\right.
|
|
\end{equation*}
|
|
|
|
\begin{multicols}{2}
|
|
|
|
Une suite de 1 donne un signal de fréquence instantanée égale à la fréquence d'horloge.
|
|
Une suite de 0 donne un signal de fréquence instantanée égale à la moitié de la fréquence d'horloge. \\
|
|
Ici, $R=2D=\frac{2}{T}$.
|
|
|
|
\columnbreak
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=1, transform shape]
|
|
\draw[-latex] (0,0) -- (5,0) node[right]{$t$};
|
|
\node at (0.5,1) {0};
|
|
\node at (1.5,1) {1};
|
|
\node at (2.5,1) {1};
|
|
\node at (3.5,1) {0};
|
|
\node at (4.5,1) {0};
|
|
\foreach \i in {0,1,...,5}{
|
|
\draw[dashed] (\i,-1) -- (\i,1);
|
|
}
|
|
\draw[red,thick] (0,-0.5) -- (0,0.5) -- (1,0.5) -- (1,-0.5) -- (1.5,-0.5) -- (1.5,0.5) -- (2,0.5) -- (2,-0.5) -- (2.5,-0.5) -- (2.5,0.5) -- (3,0.5) -- (3,-0.5) -- (4,-0.5) -- (4,0.5) -- (5,0.5);
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\end{multicols}
|
|
|
|
\paragraph{Code MFM (Modified FM) ou code de Miller}
|
|
|
|
Identique au code FM sauf qu'on supprime la transition initiale pour les 1 ainsi que pour un 0 qui suit immédiatement un 1.
|
|
L'objectif est de diminuer en valeur instantanée la rapidité de modulation.
|
|
|
|
% TODO: add tikz
|
|
|
|
\paragraph{Code M2 FM ou code de Miller 2}
|
|
|
|
Identique au code MFM sauf qu'on supprime une fois sur deux la transition initiale pour une suite de 0.
|
|
L'objectif est de ralentir les variations du signal et de resserrer le spectre.
|
|
|
|
Les propriétés~\ref{itm:prop-a},~\ref{itm:prop-b},~\ref{itm:prop-c} et~\ref{itm:prop-f} sont respectées.
|
|
|
|
\subsubsection{Code CMI (Coded Mark Inversion)}
|
|
|
|
C'est un code \emph{antipolaire} à mémoire~: \(
|
|
\left\{
|
|
\begin{array}{l}
|
|
0 \rightarrow H \; (\text{signal d'horloge}) \\
|
|
1 \rightarrow \pm V \text{ alternativement} \\
|
|
\end{array}
|
|
\right.
|
|
\)
|
|
|
|
\begin{multicols}{2}
|
|
|
|
Les propriétés~\ref{itm:prop-a},~\ref{itm:prop-b},~\ref{itm:prop-c},~\ref{itm:prop-d},~\ref{itm:prop-e},~\ref{itm:prop-f},~\ref{itm:prop-g} sont respectées. \\
|
|
Ici, $R=2D=\frac{2}{T}$. \\
|
|
Ce code est auto-porteur de son horloge.
|
|
|
|
\columnbreak
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=1, transform shape]
|
|
\draw[-latex] (0,0) -- (6,0) node[right]{$t$};
|
|
\node at (0.5,1) {0};
|
|
\node at (1.5,1) {1};
|
|
\node at (2.5,1) {1};
|
|
\node at (3.5,1) {0};
|
|
\node at (4.5,1) {0};
|
|
\node at (5.5,1) {1};
|
|
\foreach \i in {0,1,...,6}{
|
|
\draw[dashed] (\i,-1) -- (\i,1);
|
|
}
|
|
\draw[red,thick] (0,0.5) -- (0.5,0.5) -- (0.5,-0.5) -- (2,-0.5) -- (2,0.5) -- (3.5,0.5) -- (3.5,-0.5) -- (4,-0.5) -- (4,0.5) -- (4.5,0.5) -- (4.5,-0.5) -- (6,-0.5);
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\end{multicols}
|
|
|
|
\subsubsection{Code biphase différentiel}
|
|
|
|
\begin{equation*}
|
|
\left\{
|
|
\begin{array}{l}
|
|
0 \rightarrow \text{ le signal reste lui-même} \\
|
|
1 \rightarrow \text{ le signal s'inverse} \\
|
|
\end{array}
|
|
\right.
|
|
\end{equation*}
|
|
|
|
L'idée est de s'affranchir de la phase de l'horloge.
|
|
|
|
Il y a des défauts pour le code biphase classique~:
|
|
|
|
\begin{itemize}
|
|
\item Il faut comparer le signal à $H$ ou $\overline{H}$ pour décider 0 ou 1.
|
|
\item Pour la récupération d'horloge, il peut subsister une erreur de phase voire une inversion de phase, ce qui entraîne une inversion des 0 et des 1.
|
|
\end{itemize}
|
|
|
|
Avec le code biphase différentiel~:
|
|
|
|
\begin{itemize}
|
|
\item Une fois le premier symbole décodé, le problème est résolu.
|
|
\item On va mettre une séquence d'en-tête particulière qui sert de synchronisation.
|
|
\end{itemize}
|
|
|
|
\subsubsection{Code suffixé M ou S}
|
|
|
|
Désigne en particulier le NRZ-M, NRZ-S, Biphase-M et Biphase-S.
|
|
|
|
\hfill
|
|
NRZ-M~: \(
|
|
\left\{
|
|
\begin{array}{l}
|
|
0 \rightarrow \text{ pas de transition} \\
|
|
1 \rightarrow \text{ transition à } t=0 \\
|
|
\end{array}
|
|
\right.
|
|
\)
|
|
\hfill
|
|
NRZ-S~: rôle inverse 0 et 1
|
|
\hfill{}
|
|
|
|
Biphase-M~: transition systématique en $t=0$, puis \(
|
|
\left\{
|
|
\begin{array}{l}
|
|
0 \rightarrow \text{ pas d'autre transition} \\
|
|
1 \rightarrow \text{ une autre transition en } t=\frac{T}{2} \\
|
|
\end{array}
|
|
\right.
|
|
\)
|
|
|
|
Biphase-S~: rôle inverse 0 et 1
|
|
|
|
\subsection{Codes de voie trivalents}
|
|
|
|
\subsubsection{Code AMI (Alternated Mark Inversion)}
|
|
|
|
\hfill
|
|
\(
|
|
\left\{
|
|
\begin{array}{l}
|
|
0 \rightarrow 0 \\
|
|
1 \rightarrow \pm V \text{ alternativement} \\
|
|
\end{array}
|
|
\right.
|
|
\)
|
|
\hfill
|
|
Les propriétés~\ref{itm:prop-a},~\ref{itm:prop-b},~\ref{itm:prop-c} et~\ref{itm:prop-g} sont respectées.
|
|
\hfill{}
|
|
|
|
\subsubsection{Code HDB3}
|
|
|
|
Identique au code AMI sauf que~:
|
|
|
|
\begin{itemize}
|
|
|
|
\item \emph{Bit de viol} ---
|
|
Après une suite de trois 0, un quatrième 0 éventuel est représenté comme le serait un 1, mais en violant la règle d'alternance des signes~: 0000 devient 000V.
|
|
|
|
\item \emph{Bit de bourrage} ---
|
|
On veut conserver une valeur moyenne nulle.
|
|
On alterne la polarité des \emph{viols} et on ajoute un bit de \emph{bourrage} de même polarité que le \emph{viol}, placé en tête du groupe des quatre symboles 0~: 0000 devient B000V.
|
|
|
|
\end{itemize}
|
|
|
|
\subsection{Codes arithmétiques (transformation de valence)}
|
|
|
|
L'objectif est de diminuer la rapidité de modulation sans modifier le débit binaire de la source.
|
|
|
|
Principe~:
|
|
\begin{itemize}
|
|
\item une séquence à valence 2 devient une séquence plus courte à valence $>2$
|
|
\item le code se note $nBmX$ avec $n$ éléments binaires qui donne $m$ éléments d'un alphabet $X$-aire
|
|
\item pour que ce soit faisable, il faut que $2^n \leq X^m$
|
|
\end{itemize}
|
|
|
|
On a par exemple le code 4B3T ou 2B1Q.
|
|
|
|
\subsubsection{Code 4B3T}
|
|
|
|
\hfill $2^4 = 16 < 27 = 3^3$
|
|
|
|
Une séquence de 4 symboles binaires donne une séquence de 3 symboles ternaires. \\
|
|
La séquence 3T va être codée sous forme bipolaire ($+V, 0, -V$).
|
|
Il est possible d'affecter à certaines séquences 4B plusieurs séquences 3T.
|
|
|
|
L'objectif est d'avoir une valeur moyenne à court terme la plus faible possible.
|
|
La valeur de la somme cumulée doit approcher 0.
|
|
|
|
\subsubsection{Code 2B1Q}
|
|
|
|
\hfill $2^2 = 4^1$
|
|
|
|
Une séquence de 2 symboles binaires donne un symbole quaternaire. \\
|
|
La séquence 1Q va être codée sous forme antipolaire ($+2V, +V, -V, -2V$).
|
|
Il n'y a pas de possibilité de contrôler la valeur moyenne, mais la rapidité de modulation est plus réduite.
|
|
$R=\frac{D}{2}=\frac{1}{2T}$
|
|
|
|
\subsection{Exemples de spectres}
|
|
|
|
% TODO: make into tikz ?
|
|
\includegraphics[width=0.5\linewidth]{./img/exemples_spectres_1.png}
|
|
\includegraphics[width=0.5\linewidth]{./img/exemples_spectres_2.png}
|
|
|
|
\subsection{Exemples d'utilisation des codes}
|
|
|
|
\begin{tabularx}{\linewidth}{lX}
|
|
\toprule
|
|
\textbf{Code} & \textbf{Utilisation} \\
|
|
\toprule
|
|
Code NRZ & Fast Ethernet (100BaseFx), FDDI \\
|
|
\midrule
|
|
Code MLT & Fast Ethernet (100BaseTx, 100BaseT4), ATM \\
|
|
\midrule
|
|
Manchester & Ethernet 10Base5, 10Base2, 10BaseT, 10BaseFL \\
|
|
\midrule
|
|
Manchester différentiel & Token-Ring \\
|
|
\midrule
|
|
Code bipolaire & Ligne DS1, T1 (1.5 Mbps, normalisation PDH US) \\
|
|
\midrule
|
|
HDB3 & E1 (2 Mbps, normalisation PDH US) \\
|
|
\midrule
|
|
\multirow{2}{*}{nBmB} & 4B5B Fast Ethernet \\
|
|
& 8B10B Giga Ethernet \\
|
|
\bottomrule
|
|
\end{tabularx}
|
|
|
|
\section{Transmission sur un canal à bande illimitée}
|
|
|
|
\subsection{Effet du bruit additif sur un code bivalent equiprobable}
|
|
|
|
Soit $x(t)$ un signal binaire émis, bivalent et unipolaire ($+V, -V$).
|
|
Soit $n(t)$ le bruit additif, de loi de probabilité gaussienne centrée et de variance $\sigma^2$.
|
|
|
|
On reçoit $r(t) = x(t) + n(t)$.
|
|
Le résultat est comparé à 0, seuil de décision.
|
|
|
|
\begin{itemize}
|
|
\item si $r(t) < 0$~: $-V$ émis, symbole reçu~: 0
|
|
\item si $r(t) > 0$~: $+V$ émis, symbole reçu~: 1
|
|
\end{itemize}
|
|
|
|
\begin{center}
|
|
\includegraphics[width=0.5\linewidth]{./img/effet_bruit_additif.png}
|
|
\end{center}
|
|
|
|
La probabilité d'erreur, ou BER (Bit Error Ratio) est alors~:
|
|
\begin{align*}
|
|
P_e &= P[x(t) = +V] \cdot P[n(t) < -V] + P[x(t) = -V] \cdot P[n(t) > +V] \\
|
|
&= P(1) \cdot P[n(t) < -V] + P(0) \cdot P[n(t) > +V]
|
|
\end{align*}
|
|
|
|
Dans le cas d'une source equiprobable, $P(0) = P(1) = \frac{1}{2}$, donc~:
|
|
\begin{equation*}
|
|
P_e = \frac{1}{2} [P(n(t) < -V) + P(n(t) > +V)]
|
|
\end{equation*}
|
|
|
|
Le bruit $n(t)$ est une variable aléatoire gaussienne de probabilité \(
|
|
p(n) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{n^2}{2\sigma^2}}
|
|
\).
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\begin{tikzpicture}
|
|
\node at (4.1,4) {\small$\sigma=0.3$};
|
|
\node at (4.6,1.2) {\small$\sigma=1$};
|
|
\node at (6,0.7) {\small$\sigma=2$};
|
|
\node[red] at (1.5,-0.2) {\tiny$-V$};
|
|
\node[blue] at (4.6,-0.2) {\tiny$+V$};
|
|
\begin{axis}[
|
|
every axis plot post/.append style={mark=none,samples=50,smooth},
|
|
axis x line=bottom, axis y line=left, enlargelimits=upper]
|
|
\addplot[black,domain=-3:3]{gauss(0,0.3)};
|
|
\addplot[black,domain=-3:3]{gauss(0,1)};
|
|
\addplot[black,domain=-3:3]{gauss(0,2)};
|
|
|
|
\addplot[domain=-3:-1.5,name path=A]{gauss(0,1)};
|
|
\path[name path=left] (axis cs:-3,0) -- (axis cs:-1.5,0);
|
|
\addplot [red!30] fill between[of=A and left];
|
|
\addplot[domain=1.5:3,name path=B]{gauss(0,1)};
|
|
\path[name path=right] (axis cs:1.5,0) -- (axis cs:3,0);
|
|
\addplot [blue!30] fill between[of=B and right];
|
|
\end{axis}
|
|
\end{tikzpicture}
|
|
|
|
\begin{equation*}
|
|
\underbrace{P(n(t) < -V)}_{\color{red}{\int_{-\infty}^{-V} p(n) \dif n}}
|
|
= \underbrace{P(n(t) > +V)}_{\color{blue}{\int_{+V}^{+\infty} p(n) \dif n}}
|
|
= \int_{+V}^{+\infty} p(n) \dif n
|
|
\end{equation*}
|
|
|
|
\end{multicols}
|
|
|
|
\begin{align*}
|
|
P_e &= \frac{1}{2} [P(n(t) < -V) + P(n(t) > +V)] \\
|
|
&= \int_{+V}^{+\infty} p(n) \dif n
|
|
= \frac{1}{\sigma\sqrt{2\pi}} \int_{+V}^{+\infty} e^{-\frac{n^2}{2\sigma^2}} \dif n \\
|
|
\end{align*}
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\begin{equation*}
|
|
P_e = \frac{1}{2} \mathrm{erfc}\left(\frac{+V}{\sigma\sqrt{2}}\right)
|
|
= \frac{1}{2} \left(1-\mathrm{erf }\left(\frac{+V}{\sigma\sqrt{2}}\right)\right)
|
|
\end{equation*}
|
|
\begin{itemize}
|
|
\item $\sigma^2$ est la puissance du bruit
|
|
\item $V^2$ est la puissance du signal numérique
|
|
\end{itemize}
|
|
|
|
On obtient alors $P_e = \frac{1}{2} \mathrm{erfc}\sqrt{\frac{S}{N}}$
|
|
\begin{itemize}
|
|
\item $S$~: puissance du signal émis $x(t)$
|
|
\item $N$~: puissance du bruit gaussien $n(t)$
|
|
\end{itemize}
|
|
|
|
\columnbreak
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.8, transform shape]
|
|
\draw[help lines, dashed] (6,-2) grid (14,-12);
|
|
\draw[-latex] (6,-12) -- (14.5,-12) node [above]{S/N} node[below]{dB};
|
|
\draw[-latex] (6,-12) -- (6,-1.5) node[right]{$P_e$};
|
|
\foreach \i in {6,7,...,14}{\node at (\i,-12.3) {\small\i};}
|
|
\foreach \i in {-2,-3,...,-12}{\node at (5.5,\i) {\small$10^{\i}$};}
|
|
\draw (13.5,-12) arc[start angle=0, end angle=75.5,radius=10cm];
|
|
\draw [red,thick] (6,-9) -- (13,-9) -- (13,-12);
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
Pour un taux d'erreur max de $10^{-9}$, le rapport S/N doit être d'au moins 13.
|
|
|
|
\end{multicols}
|
|
|
|
\subsection{Effet du bruit additif sur un code bivalent non equiprobable}
|
|
|
|
Pour diminuer les erreurs, il est plus intéressant d'éloigner le seuil de décision du niveau le plus probable.
|
|
On obtient comme seuil optimal~:
|
|
|
|
\begin{equation*}
|
|
S_0 = \frac{\sigma^2}{2V} \ln{\frac{P(0)}{P(1)}}
|
|
\end{equation*}
|
|
|
|
\subsection{Cas général d'un code multivalent}
|
|
|
|
Prenons un exemple d'un code de valence 4, avec des seuils de décisions choisis avec la règle triviale du ``mi-chemin'', avec des symboles equiprobables.
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=1, transform shape]
|
|
\draw[-latex] (-3.1,0) -- (3.4,0);
|
|
\foreach \i in {-3,-2,...,3}{\draw (\i,0) -- (\i,0.1);}
|
|
\node at (-3,0.6) {-3V};
|
|
\node at (-2,0.6) {-2V};
|
|
\node at (-1,0.6) {-V};
|
|
\node at (1,0.6) {V};
|
|
\node at (2,0.6) {2V};
|
|
\node at (3,0.6) {3V};
|
|
\foreach \i in {-2.5,-1.5,0,1.5,2.5}{\draw[->] (\i,-1) -- (\i,-0.4) node[at start,below] {\small \i V};}
|
|
\node at (4,1) {émis};
|
|
\node at (4,-1) {décision};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\begin{equation*}
|
|
P_e = P_e(-3V) + P_e(-2V) + P_e(-V) + P_e(+V) + P_e(2V) + P_e(3V)
|
|
\end{equation*}
|
|
|
|
\begin{align*}
|
|
P_e(+V) = [P(n(t)>0.5V) + P(n(t)<-V)] \cdot P(V) \\
|
|
\text{ car }
|
|
\left\{
|
|
\begin{array}{l}
|
|
+V - V = 0 \rightarrow \text{ seuil de décision inférieur} \\
|
|
+V + 0.5V = 1.5 \rightarrow \text{ seuil de décision supérieur} \\
|
|
\end{array}
|
|
\right.
|
|
\end{align*}
|
|
|
|
\subsection{Filtrage du bruit}
|
|
|
|
\section{Transmission sur un canal à bande limitée --- Interférence inter-symboles}
|
|
|
|
\section{Transmission sur onde porteuse~: les modulations numériques}
|
|
|
|
\end{document}
|