\documentclass[a4paper,french,12pt]{article}

\title{Communications Numériques}
\author{}
\date{Dernière compilation~: \today{} à \currenttime}

\usepackage{styles}
\usepackage{circuitikz}
\usepackage{pgfplots}
\usepgfplotslibrary{fillbetween}

\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\label{par: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}

        \hfill
        \begin{tikzpicture}[scale=1, transform shape]
            \node[rectangle,draw,label={below:codeur}] (codeur) at (0,0) {$\underline{G(f)}$};
            \node[rectangle,draw,label={below:canal}] (canal) at (2,0) {$\underline{B(f)}$};
            \draw[-latex] (-1.5,0) -- (codeur) node[above,midway]{$a(t)$};
            \draw[-latex] (codeur) -- (canal) node[above,midway]{$e(t)$};
            \draw[-latex] (2,1.3) -- (canal) node[above,at start]{$n(t)$};
            \draw[-latex] (canal) -- (3.5,0) node[above,midway]{$r(t)$};
        \end{tikzpicture}
        \hfill
        $r(t) = [a*g*b](t) + [n*b](t)$
        \hfill{}

        Dans le cas d'une source binaire, $\pm V$ émis, et d'une source de bruit de DSP égale à $\frac{N_0}{2}$~:

        \begin{itemize}

            \item L'énergie $W_s$ du signal reçu (signal seul) vaut~:
                $W_s = V^2 \int_{-\infty}^{+\infty} |\underline{G(f)}|^2 \cdot |\underline{B(f)}|^2 \dif f$

            \item L'énergie $W_n$ du bruit reçu (bruit seul) vaut~:
                $W_n = \frac{N_0}{2} \int_{-\infty}^{+\infty} |\underline{B(f)}|^2 \dif f$

        \end{itemize}

        Inégalité de Schwartz~:
        \begin{equation*}
            \frac{W_s}{W_n} = \frac{2V^2}{N_0} \frac{\int_{-\infty}^{+\infty}|\underline{G(f)}|^2 \cdot |\underline{B(f)}|^2 \dif f}
            {\int_{-\infty}^{+\infty} |\underline{B(f)}|^2 \dif f}
            \leq
            \frac{2V^2}{N_0} \frac{\int_{-\infty}^{+\infty} |\underline{G(f)}|^2 \dif f \int_{-\infty}^{+\infty} |\underline{B(f)}|^2 \dif f}
            {\int_{-\infty}^{+\infty} |\underline{B(f)}|^2 \dif f}
        \end{equation*}
        Soit~:
        \begin{equation*}
            \frac{W_s}{W_n} \leq \frac{2V^2}{N_0} \int_{-\infty}^{+\infty} |\underline{G(f)}|^2 \dif f
        \end{equation*}

        Le membre de droite est la valeur maximale du rapport $\frac{W_s}{W_n}$, atteinte lorsque $|\underline{G(f)}|$ et $|\underline{B(f)}|$ sont proportionnels.

        Le filtre du canal est optimal lorsque $\underline{B(f)}=\underline{G(f)}$, où $\underline{G(f)}$ est la transformée de Fourier de la réponse du codeur.
        Mais en pratique, $\underline{B(f)} \neq \underline{G(f)}$.

        Si l'on note $\underline{C_0(f)}$ le filtre naturel du canal, on rajoute au niveau du récepteur un filtre $\underline{R(f)}$ tel que~:
        \begin{equation*}
            \underline{B(f)} = \underline{C_0(f)} \cdot \underline{R(f)}
        \end{equation*}
        On obtiendra alors un filtre adapté.

        Si $\underline{C_0(f)}$ est quasi-constante dans la bande passante de $\underline{G(f)}$, alors~:

        \begin{center}
        \begin{tikzpicture}[scale=1, transform shape]
            \node[rectangle,draw,label={below:codeur}] (codeur) at (0,0) {$\underline{G(f)}$};
            \node[rectangle,draw,label={below:canal}] (canal) at (2,0) {$\underline{C_0(f)}$};
            \node[rectangle,draw,label={below:filtre}] (filtre) at (4,0) {$\underline{R(f)}$};
            \draw[-latex] (-1.5,0) -- (codeur) node[above,midway]{$a(t)$};
            \draw[-latex] (codeur) -- (canal) node[above,midway]{$e(t)$};
            \draw[-latex] (canal) -- (filtre);
            \draw[-latex] (filtre) -- (5.5,0);
            \draw [decorate, decoration={brace,amplitude=10pt,raise=15pt}]
                (filtre.south east) -- (canal.south west) node [below=0.8cm,midway,sloped] {$\underline{B(f)}=\underline{G(f)}$};
        \end{tikzpicture}
        \end{center}

        Sinon, on réalise d'abord une correction de canal, filtre inverse de $\underline{C_0(f)}$ dans la bande passante de $\underline{G(f)}$ et le fait suivre par un filtre $\underline{R(f)} = \underline{G(f)}$~:

        \begin{center}
        \begin{tikzpicture}[scale=1, transform shape]
            \node[rectangle,draw,label={below:codeur}] (codeur) at (0,0) {$\underline{G(f)}$};
            \node[rectangle,draw,label={below:canal}] (canal) at (2,0) {$\underline{C_0(f)}$};
            \node[rectangle,draw,label={below:correcteur}] (correcteur) at (4,0) {$\underline{C_0^{-1}(f)}$};
            \node[rectangle,draw,label={below:filtre}] (filtre) at (6,0) {$\underline{R(f)}$};
            \draw[-latex] (-1.5,0) -- (codeur) node[above,midway]{$a(t)$};
            \draw[-latex] (codeur) -- (canal) node[above,midway]{$e(t)$};
            \draw[-latex] (canal) -- (correcteur);
            \draw[-latex] (correcteur) -- (filtre);
            \draw[-latex] (filtre) -- (7.5,0);
            \draw [decorate, decoration={brace,amplitude=10pt,raise=15pt}]
                (0.9,-0.4) -- (-1.5,-0.4) node [below=0.8cm,midway,sloped] {émission};
            \draw [decorate, decoration={brace,amplitude=10pt,raise=15pt}]
                (3,-0.4) -- (1.1,-0.4) node [below=0.8cm,midway,sloped] {transmission};
            \draw [decorate, decoration={brace,amplitude=10pt,raise=15pt}]
                (filtre.south east) -- (correcteur.south west) node [below=0.8cm,midway,sloped] {réception};
        \end{tikzpicture}
        \end{center}

\section{Transmission sur un canal à bande limitée --- Interférence inter-symboles}

    \subsection{Modèle préalable du codage et de la transmission}

        \begin{tabularx}{\linewidth}{YY}
            & {
            \begin{tikzpicture}[scale=1, transform shape]
                \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]{$e(t)$};
            \end{tikzpicture}
            } \\
            $e(t) = (a*g)(t)$ & {
            \begin{tikzpicture}[scale=1, transform shape]
                \node [rectangle,draw,minimum height=0.8cm,minimum width=2cm] (lcodeur) at (0,-2) {$\underline{G(f)}$};
                \draw [latex-] (lcodeur) -- ++(-2cm,0) node[above]{$a(t)$};
                \draw [-latex] (lcodeur) -- ++(2cm,0) node[above]{$e(t)$};
            \end{tikzpicture}
            } \\
            $a(t) = \sum_{k=-\infty}^{+\infty} a_k \delta(t-kT)$ & {
            \begin{tikzpicture}[scale=1, transform shape]
                \draw [-latex] (-3,-5) -- (3,-5) node[below]{$t$};
                \draw [-latex] (-2.5,-5.5) -- (-2.5,-3) node[left]{$a(t)$};
                \foreach \i in {-2.5,-1,2}{
                    \draw [-latex,red,thick] (\i,-5) -- (\i,-4);
                }
                \draw [-latex,red,thick] (0.5,-5) -- (0.5,-6);
            \end{tikzpicture}
            } \\
        \end{tabularx}

    \subsection{Premier théorême de Nyquist}

        Soit $H(f)$ un filtre passe-bas idéal, de fréquence de coupure $f_c$.

        \hfill
        \begin{tikzpicture}[scale=1.5, transform shape]
            \draw[-latex] (-7.2,0) -- (-3.2,0) node[right]{$f$};
            \draw[-latex] (-5,0) -- (-5,1.5) node[right]{$H(f)$};
            \draw[red,thick] (-7,0) -- (-6,0) -- (-6,1) -- (-4,1) -- (-4,0) -- (-3,0);
            \node at (-5,-0.3) {\footnotesize 0};
            \node at (-6,-0.3) {\footnotesize $-f_c$};
            \node at (-4,-0.3) {\footnotesize $f_c$};

            \draw[-latex] (-2.2,0) -- (2.2,0) node[right]{$t$};
            \draw[-latex] (0,0) -- (0,1.5) node[right]{$h(t)$};
            \draw[thick,red]
                (-1.5,0)
                sin (-1.25,0.25) cos (-1,0) sin (-0.75,-0.25) cos (-0.5,0)
                sin (0,1) cos (0.5,0)
                sin (0.75,-0.25) cos (1,0) sin (1.25,0.25) cos (1.5,0)
                ;
            \node at (1.5,1) {\parbox{1.5cm}{\tiny réponse\\impulsionnelle}};
            \node at (0,-0.3) {\footnotesize 0};
            \node at (-0.5,-0.45) {\tiny$\sfrac{-1}{2f_c}$};
            \draw (-0.5,-0.1) -- (-0.5,0.1);
            \node at (0.5,-0.45) {\tiny$\sfrac{1}{2f_c}$};
            \draw (0.5,-0.1) -- (0.5,0.1);
            \node at (-1,0.45) {\tiny$\sfrac{-1}{f_c}$};
            \draw (-1,-0.1) -- (-1,0.1);
            \node at (1,0.45) {\tiny$\sfrac{1}{f_c}$};
            \draw (1,-0.1) -- (1,0.1);
        \end{tikzpicture}
        \hfill{}

        \paragraph{Rappels sur la convolution}
            \begin{tikzpicture}[scale=1, transform shape]
                \node [rectangle,draw,minimum height=0.8cm,minimum width=2cm] (lcodeur) at (0,-2) {$\underline{H(f)}$};
                \draw [latex-] (lcodeur) -- ++(-2cm,0) node[above]{$\underline{E(f)}$};
                \draw [-latex] (lcodeur) -- ++(2cm,0) node[above]{$\underline{S(f)}$};
            \end{tikzpicture}

            \begin{itemize}
                \item Domaine fréquenciel~: $\underline{S(f)} = \underline{H(f)}\underline{E(f)}$
                \item Domaine temporel~: $s(t) = (h*e)(t) = \int_{-\infty}^{+\infty} e(\tau)h(t-\tau)\dif\tau$
            \end{itemize}

        \paragraph{Premier cas}
            $\frac{1}{2f_c} < T \iff f_c > \frac{1}{2T}$

            \begin{multicols}{2}

                \begin{center}
                Regardons ce qui se passe à $t=t_0=T$~: \\
                \begin{tikzpicture}[scale=1, transform shape]
                    \draw[-latex] (-2,0) -- (4,0) node[below]{$\tau$};
                    \draw[-latex] (0,-1) -- (0,1.2) node[right]{$a(\tau)$};
                    \foreach \i in {0,1,3}{\draw[red,thick] (\i,0) -- (\i,0.7);}
                    \foreach \i in {-1,2}{\draw[red,thick] (\i,0) -- (\i,-0.7);}
                \end{tikzpicture}
                \end{center}

                \columnbreak

                \begin{equation*}
                    r(t) = (a*h)(t) = \int_{-\infty}^{+\infty} a(\tau) h(t - \tau) \dif\tau
                \end{equation*}

            \end{multicols}

        \paragraph{Deuxième cas}
            $\frac{1}{2f_c} > T \iff f_c < \frac{1}{2T}$

            \begin{multicols}{2}

                \begin{center}
                Regardons ce qui se passe à $t=t_0=T$ soit pour $a_1$~: \\
                \begin{tikzpicture}[scale=1, transform shape]
                    \draw[-latex] (-2,0) -- (4,0) node[below]{$\tau$};
                    \draw[-latex] (0,-1) -- (0,1.2) node[right]{$a(\tau)$};
                    \foreach \i in {0,1,3}{\draw[red,thick] (\i,0) -- (\i,0.7);}
                    \foreach \i in {-1,2}{\draw[red,thick] (\i,0) -- (\i,-0.7);}
                    \node at (1.3,0.2) {$a_1$};
                    \node at (2,-1) {2};
                \end{tikzpicture}
                \end{center}

                \columnbreak

                \begin{align*}
                    r(t_0) &= (a*h)(t_0) = \int_{-\infty}^{+\infty} a(\tau) h(t_0 - \tau) \dif\tau \\
                           &\implies r_1 = \sum_{k=-\infty}^{+\infty} a_k h(t_0 - kT) \neq a_1
                \end{align*}

            \end{multicols}

            Alors les fonctions $h(t-kT)$ s'additionnent entre-elles.

            \hfill
            \begin{tikzpicture}[scale=1, transform shape]
                \draw[-latex] (0,0) -- (3.5,0);
                \foreach \i in {0,1,3}{\draw[red,thick,->] (\i,0) -- (\i,1);}
                \draw[red,thick,->] (2,0) -- (2,-1);
                \node at (0,-0.3) {0};
                \node at (1,-0.3) {T};
                \node at (2,0.3) {2T};
                \node at (3,-0.3) {3T};
            \end{tikzpicture}
            \hfill
            \begin{tikzpicture}[scale=1, transform shape]
                \node [rectangle,draw] (lcodeur) at (0,-2) {$H(f)$};
                \draw [latex-] (lcodeur) -- ++(-1.5cm,0);
                \draw [-latex] (lcodeur) -- ++(1.5cm,0);
            \end{tikzpicture}
            \hfill
            \begin{tikzpicture}[scale=1, transform shape]
                \draw[-latex] (0,0) -- (3.5,0);
                \draw[dashed,black!70] (-1,0) sin (1,1) cos (3,0);
                \draw[dashed,black!70] (0,1) cos (2,0) sin (4,-1);
                \draw[dashed,black!70] (-1,-1) cos (1,0) sin (3,1);
                \draw[dashed,black!70] (0,0.3) sin (2,-0.7) cos (4,0.3);
                \foreach \i in {0,1,2,3}{
                    \draw (\i,-1) -- (\i,2);
                    \node at (\i+0.2,0.1) {\tiny \i T};
                }
                \node[red] at (1.6,1.7) {$r(t)$};
                \draw[red,thick,smooth]
                    (0,2) -- (0.25,1.8) -- (0.5,1.7) -- (0.75,1.73) --
                    (1,1.68) -- (1.18,1.4) -- (1.25,1.1) -- (1.35,0.3) --
                    (1.4,0.15) -- (1.5,0) -- (1.75,-0.2) --
                    (2,-0.28) -- (2.25,-0.27) -- (2.5,-0.2) -- (2.75,-0.13) --
                    (3,0.05) -- (3.25,0.95) -- (3.5,1.35) -- (3.75,1.5)
                    ;
            \end{tikzpicture}
            \hfill{}

            $r_k \neq a_k$~: il y a une Interférence Inter Symboles (IIS).

        \paragraph{Troisième cas}
            $\frac{1}{2f_c} = T \iff f_c = \frac{1}{2T}$

            \hfill
            \begin{tikzpicture}[xscale=0.8,yscale=1.1]
                \draw[-latex] (-3.2,0) -- (3.5,0) node[right]{$t$};
                \draw[-latex] (0,0) -- (0,1.7) node[right]{$h(t)$};
                \foreach \i in {-3,-1,...,3}{\draw (\i,-0.05) -- (\i,0.05);}
                \node at (-0.3,1.05) {1};
                \draw[thick,red]
                    (-3,0) sin (-2.5,0.2) cos (-2,0) sin (-1.5,-0.2) cos (-1,0)
                    sin (0,1) cos (1,0)
                    sin (1.5,-0.2) cos (2,0) sin (2.5,0.2) cos (3,0)
                    ;
                \node at (-3,-0.4) {\tiny$\frac{-3}{2f_c}$};
                \node[red] at (-3,-0.9) {\tiny =-3T};
                \node at (-2,0.4) {\tiny$\frac{-2}{2f_c}$};
                \node[red] at (-2,-0.9) {\tiny =-2T};
                \node at (-1,-0.4) {\tiny$\frac{-1}{2f_c}$};
                \node[red] at (-1,-0.9) {\tiny =-T};
                \node at (0,-0.2) {\tiny 0};
                \node at (1,-0.4) {\tiny$\frac{1}{2f_c}$};
                \node[red] at (1,-0.9) {\tiny =T};
                \node at (2,0.4) {\tiny$\frac{2}{2f_c}$};
                \node[red] at (2,-0.9) {\tiny =2T};
                \node at (3,-0.4) {\tiny$\frac{3}{2f_c}$};
                \node[red] at (3,-0.9) {\tiny =3T};
            \end{tikzpicture}
            \hfill
            \begin{tikzpicture}[xscale=0.8,yscale=1.1]
                \draw[-latex] (-2.2,0) -- (5.5,0) node[right]{$t$};
                \draw[-latex] (0,0) -- (0,1.7) node[right]{$h(t-kT)$};
                \foreach \i in {-2,-1,...,5}{\draw (\i,-0.05) -- (\i,0.05);}
                \draw[dashed] (2,0) -- (2,1) -- (0,1) node[left]{1};
                \draw[thick,red]
                    (-2,0) sin (-1.5,-0.1) cos (-1,0)
                    sin (-0.5,0.2) cos (0,0) sin (0.5,-0.2) cos (1,0)
                    sin (2,1) cos (3,0)
                    sin (3.5,-0.2) cos (4,0) sin (4.5,0.2) cos (5,0)
                    ;
                \node at (-1,0.4) {\tiny kT-3T};
                \node at (0,-0.4) {\tiny kT-2T};
                \node at (1,-0.4) {\tiny kT-T};
                \node at (2,-0.2) {\tiny kT};
                \node at (3,-0.4) {\tiny kT+T};
                \node at (4,0.4) {\tiny kT+2T};
                \node at (5,-0.2) {\tiny kT+3T};
            \end{tikzpicture}
            \hfill{}

            \begin{equation*}
                r(t_0) = (a*h)(t_0) = \int_{-\infty}^{+\infty} a(\tau)h(t-\tau)\dif\tau
                \implies
                r_2 = \sum_{k=-\infty}^{+\infty} a_k h(t_0-kT) = a_2
            \end{equation*}

            \begin{tabularx}{\linewidth}{YYY}
                \multirow{2}{*}{
                    \parbox{5cm}{$h(0) = 1$ \\ $h(kT) = 0 \quad \forall k \neq 0$}
                } & Donc on a bien & $\sum_{k=-\infty}^{+\infty} h(t-kT) = \delta(t-kT)$ \\
            \end{tabularx}

            \hfill Pas d'IIS~: $r_k = a_k$. \hfill{}

        \paragraph{Recherche de filtres réalisables pour lesquels il n'y a pas d'IIS}

            Le premier critère de Nyquist assure qu'il n'y a pas d'Interférence Inter-Symboles.
            Un filtre passe-bas idéal de fréquence de coupure $f_c = \frac{1}{2T}$ (moitié de la fréquence d'apparition des symboles $a_k$) satisfait ce critère.
            Le filtre est non causal donc irréalisable.

            Pour qu'il n'y ait pas d'IIS~: \(
                h(t) \; |
                \left\{
                \begin{array}{l}
                    h(0) = 1 \\
                    h(kT) = 0 \quad \forall k \neq 0 \\
                \end{array}
                \right.
            \)
            \begin{equation*}
                \iff h(t) \cdot \sum_{k=-\infty}^{+\infty} \delta(t-kT) = 1\cdot\delta(t)
            \end{equation*}

            En prenant la transformée de Fourier des deux membres~:
            \begin{align*}
                \underline{H(f)} * \sum_{n=-\infty}^{+\infty} \frac{1}{T} \delta(f-\frac{n}{T}) = 1 \\
                \iff \sum_{n=-\infty}^{+\infty} \underline{H(f-\frac{n}{T})} = T \text{ constante réelle} \\
                \text{\ldots{} qui n'est autre que } \underline{H(f)} \text{ périodisé à la fréquence } \frac{1}{T}
            \end{align*}

    \subsection{Deuxième théorême de Nyquist}

        Le premier théorême de Nyquist assure un bon échantillonnage.
        Le deuxième théorême de Nyquist assure une bonne restitution de l'horloge.
        Cela veut dire que les instants de transitions de l'horloge arrivent au bon moment.
        L'horloge est regénérée à partir du signal reçu.

        Par exemple, dans le cas d'un signal NRZ, à la réception l'échantillonnage se fait aux instants $kT$ correspondants aux fronts \emph{descendants} de l'horloge.
        Mais l'horloge est reconstituée d'après les transitions du signal, correspondants aux fronts \emph{montants}.

        La condition supplémentaire pour avoir une bonne reconstitution de l'horloge est donc~:

        \hfill \(
            \left\{
            \begin{array}{l}
                h(-\frac{T}{2}) = h(+\frac{T}{2}) \\
                h(nT \pm \frac{T}{2}) = 0 \quad \forall n \neq 0 \\
            \end{array}
            \right.
        \)
        \hfill
        \begin{tikzpicture}[xscale=1,yscale=1.2]
            \draw[-latex] (-3.5,0) -- (4.3,0) node[right]{$t$};
            \draw[-latex] (0,-1) -- (0,1.5) node[right]{$h(t)$};
            \foreach \i in {-3,-2,-1,1,2,3,4}{
                \draw (\i,-0.05) -- (\i,0.05);
            }
            \node at (-3,-0.5) {\tiny $\frac{-3T}{2}$};
            \node at (-2,-0.5) {\tiny $-T$};
            \node at (-1,-0.5) {\tiny $\frac{-T}{2}$};
            \node at (1,-0.5) {\tiny $\frac{T}{2}$};
            \node at (2,-0.5) {\tiny $T$};
            \node at (3,-0.5) {\tiny $\frac{3T}{2}$};
            \draw (-3,0) sin (-2.5,-0.15) cos (-2,0) sin (0,1) cos (2,0) sin (2.5,-0.15) cos (3,0) sin (3.5,0.1) cos (4,0);
            \node[circle,draw,red] at (-3,0) {};
            \node[circle,draw,red] at (3,0) {};
            \node[circle,draw,red] at (-1,0.7) {};
            \node[circle,draw,red] at (1,0.7) {};
        \end{tikzpicture}
        \hfill{}

        Les symboles à l'émission sont~:

        \begin{multicols}{2}

            \begin{tikzpicture}[scale=1, transform shape]
                \draw[-latex] (-0.2,0) -- (4.4,0) node[right]{$t$};
                \draw[-latex] (0,0) -- (0,1.9);
                \node at (0,-0.3) {\small 0};
                \node at (2,-0.3) {\small T};
                \node at (3,-0.3) {\small $\theta$};
                \node at (4,-0.3) {\small 2T};
                \draw[->,red,thick] (0,0) -- (0,1) node[left]{a};
                \draw[->,red,thick] (2,0) -- (2,1) node[left]{b};
                \draw[->,red,thick] (4,0) -- (4,-1) node[left]{c};
            \end{tikzpicture}

            \columnbreak

            Il y a une transition entre les symboles b et c, soit en $\theta = \frac{3T}{2}$ et que l'on veut retrouver.
            Il faut donc un 0 en $\theta$ à la réception ($r(\theta)=0$).

        \end{multicols}

        \begin{itemize}

            \item Contribution du symbole a~:
                \begin{align*}
                    a(t) = a\delta(0) * h(t) \\
                    a(\theta) = 0
                \end{align*}

            \item Contribution du symbole b~:
                \begin{align*}
                    b(t) = b\delta(t-T) * h(t) \\
                    b(\theta) = h(t+\frac{T}{2})
                \end{align*}

            \item Contribution du symbole c~:
                \begin{align*}
                    c(t) = c\delta(t-2T) * h(t) \\
                    c(\theta) = -h(t-\frac{T}{2})
                \end{align*}

        \end{itemize}

        \begin{equation*}
            \text{Donc }
            \left\{
            \begin{array}{l}
                a(\theta) = 0 \\
                b(\theta) = -c(\theta) \\
            \end{array}
            \right. \implies a(\theta) + b(\theta) + c(\theta) = 0
        \end{equation*}

    \subsection{Filtre adapté aux deux critères de Nyquist}

        \begin{itemize}

            \item Pour respecter le premier critère et éviter l'IIS~:
                \begin{equation*}
                    \sum_{n=-\infty}^{+\infty} \underline{H(f-\frac{n}{T})} = T
                \end{equation*}

            \item Pour respecter le deuxième critère et avoir une bonne restitution d'horloge~:
                \begin{equation*}
                    \sum_{n=-\infty}^{+\infty} \underline{H(f-\frac{n}{T})} e^{j\pi n} = T \cos(\pi fT)
                \end{equation*}

        \end{itemize}

        Cette fonction répondant aux deux critères est unique (cosinus surélevé)~:
        \begin{equation*}
            \underline{H(f)} = 1 + \cos(\pi fT) = 2\cos^2(\pi f \frac{T}{2})
        \end{equation*}

        Ce $h(t)$ est difficilement réalisable.

        On peut par contre avoir un intermédiaire entre le filtre passe-bas idéal et un filtre en cosinus surélevé~:

        \begin{center}
        \begin{tikzpicture}[scale=1.5, transform shape]
            \draw[-latex] (-4.2,0) -- (4.5,0) node[right]{\small $f$};
            \draw[-latex] (0,0) -- (0,2.4) node[right]{\small $H(f)$};
            \node at (0,-0.2) {\tiny 0};
            \node at (2,-0.2) {\tiny $(1-\alpha)f_c$};
            \node at (3,-0.2) {\tiny $f_c$};
            \node at (4,-0.2) {\tiny $(1+\alpha)f_c$};
            \draw [dashed,black!70] (2,0) -- (2,2);
            \draw [dashed,black!70] (0,1) -- (3,1) -- (3,0);
            \draw[red,thick] (-4,0) cos (-3,1) sin (-2,2) -- (2,2) cos (3,1) sin (4,0);
        \end{tikzpicture}
        \end{center}

        Le coefficient $\alpha$, dit \emph{d'arrondi}, est appelé \emph{roll-off filter}.

        $\alpha=0$ donne le filtre passe-bas idéal, de fréquence de coupure $\frac{1}{2T}$. \\
        $\alpha=1$ donne un filtre en cosinus surélevé. \\
        En pratique, on va prendre $0.3 \leq \alpha \leq 0.7$, mais pour toute valeur de $\alpha$, il n'y aura pas d'IIS\@.

\section{Transmission sur onde porteuse~: les modulations numériques}

    La modulation numérique a deux intérêts~:
    \begin{enumerate}

        \item \textbf{Adapter le signal au canal de transmission} ---
            Cela consiste à moduler une porteuse $p(t)$ par le signal d'information $x(t)$ et à transmettre le signal modulé $e(t)$ sur le canal de transmission.
            À la réception, on fait le contraire (démodulation)~: à partir du signal $r(t)$ on obtient $x(t)_e$, idéalement égal à $e(t)$.

        \item \textbf{Multiplexer plusieurs signaux sur un même canal de transmission} ---
            Si l'on additionne les différents signaux à transmettre, impossible de les différencier à l'arrivée.
            Par contre, on peut moduler les porteuses de fréquences différentes afin de dissocier les spectres.

            \hfill
            \begin{tikzpicture}[scale=2]
                \draw (-1,0) -- (1,0);
                \foreach \i in {-1,-0.5,...,1}{
                    \draw (\i,0) -- (\i,0.04);
                    \node at (\i,-0.2) {\tiny \i};
                }
                \draw[blue,very thick] (0,0) -- (0,1);
            \end{tikzpicture}
            \hfill
            \begin{tikzpicture}[scale=2]
                \draw (-1,0) -- (1,0);
                \foreach \i in {-1,-0.5,...,1}{
                    \draw (\i,0) -- (\i,0.04);
                    \node at (\i,-0.2) {\tiny \i};
                }
                \draw[red,very thick] (0,0) -- (0,1);
            \end{tikzpicture}
            \hfill
            \begin{tikzpicture}[scale=2]
                \draw (-1,0) -- (1,0);
                \foreach \i in {-1,-0.5,...,1}{
                    \draw (\i,0) -- (\i,0.04);
                    \node at (\i,-0.2) {\tiny \i};
                }
                \draw[green,very thick] (0,0) -- (0,1);
            \end{tikzpicture}
            \hfill{}

            \begin{center}
            \begin{tikzpicture}[scale=2]
                \draw [thick,decorate, decoration={brace,amplitude=10pt}] (3.5,1.4) -- (-3.5,1.4);
                \draw (-1,0) -- (1,0);
                \foreach \i in {-1,-0.5,...,1}{
                    \draw (\i,0) -- (\i,0.04);
                    \node at (\i,-0.2) {\tiny \i};
                }
                \draw[blue,very thick] (-0.25,0) -- (-0.25,1);
                \draw[blue,very thick] (0.25,0) -- (0.25,1);
                \draw[red,very thick] (-0.5,0) -- (-0.5,1);
                \draw[red,very thick] (0.5,0) -- (0.5,1);
                \draw[green,very thick] (-0.75,0) -- (-0.75,1);
                \draw[green,very thick] (0.75,0) -- (0.75,1);
            \end{tikzpicture}
            \end{center}

    \end{enumerate}

    \subsection{Principe de la modulation}

        Soit $m(t)$ le signal d'information à transmettre.
        Soit la porteuse $p(t) = A \cos(2\pi ft + \varphi)$.

        Moduler, c'est changer une ou deux caractéristiques de la porteuse suivant $m(t)$~:

        \begin{itemize}
            \item $A$~: modulation d'amplitude
            \item $f$~: modulation de fréquence
            \item $\varphi$~: modulation de phase
            \item $A$ et $\varphi$~: modulation de phase et d'amplitude
        \end{itemize}

    \subsection{Modulation d'amplitude (ASK, Amplitude Shift Keying)}

        On choisit deux amplitudes différentes pour les 0 et les 1 dans le cas d'un signal bivalent.
        Sinon, le OOF (On/Off Keying), c'est quand 0 = aucun signal et 1 = la porteuse.

        \begin{center}
        \begin{tikzpicture}[scale=1]
            \draw (0,0) -- (11,0);
            \foreach \i in {0,1,...,11}{
                \draw[dashed,black!60] (\i,-1.3) -- (\i,1.5);
            }
            \foreach \i in {0,3,5}{
                \node at (\i+0.5,1.5) {\small 00};
            }
            \foreach \i in {1,8}{
                \node at (\i+0.5,1.5) {\small 11};
            }
            \foreach \i in {2,4,9,10}{
                \node at (\i+0.5,1.5) {\small 01};
            }
            \foreach \i in {6,7}{
                \node at (\i+0.5,1.5) {\small 10};
            }
            \draw[red,thick]
                (0,0) sin (0.125,-0.25) cos (0.25,0) sin (0.375,0.25) cos (0.5,0)
                      sin (0.625,-0.25) cos (0.75,0) sin (0.875,0.25) cos (1,0)
                      sin (1.125,-1) cos (1.25,0) sin (1.375,1) cos (1.5,0)
                      sin (1.625,-1) cos (1.75,0) sin (1.875,1) cos (2,0)
                      sin (2.125,-0.5) cos (2.25,0) sin (2.375,0.5) cos (2.5,0)
                      sin (2.625,-0.5) cos (2.75,0) sin (2.875,0.5) cos (3,0)
                      sin (3.125,-0.25) cos (3.25,0) sin (3.375,0.25) cos (3.5,0)
                      sin (3.625,-0.25) cos (3.75,0) sin (3.875,0.25) cos (4,0)
                      sin (4.125,-0.5) cos (4.25,0) sin (4.375,0.5) cos (4.5,0)
                      sin (4.625,-0.5) cos (4.75,0) sin (4.875,0.5) cos (5,0)
                      sin (5.125,-0.25) cos (5.25,0) sin (5.375,0.25) cos (5.5,0)
                      sin (5.625,-0.25) cos (5.75,0) sin (5.875,0.25) cos (6,0)
                      sin (6.125,-0.75) cos (6.25,0) sin (6.375,0.75) cos (6.5,0)
                      sin (6.625,-0.75) cos (6.75,0) sin (6.875,0.75) cos (7,0)
                      sin (7.125,-0.75) cos (7.25,0) sin (7.375,0.75) cos (7.5,0)
                      sin (7.625,-0.75) cos (7.75,0) sin (7.875,0.75) cos (8,0)
                      sin (8.125,-1) cos (8.25,0) sin (8.375,1) cos (8.5,0)
                      sin (8.625,-1) cos (8.75,0) sin (8.875,1) cos (9,0)
                      sin (9.125,-0.5) cos (9.25,0) sin (9.375,0.5) cos (9.5,0)
                      sin (9.625,-0.5) cos (9.75,0) sin (9.875,0.5) cos (10,0)
                      sin (10.125,-0.5) cos (10.25,0) sin (10.375,0.5) cos (10.5,0)
                      sin (10.625,-0.5) cos (10.75,0) sin (10.875,0.5) cos (11,0)
                ;
        \end{tikzpicture}
        \end{center}

    \subsection{Modulation de fréquence (FSK, Frequency Shift Keying)}

        On attribue des fréquences de porteuses différentes en fonction de la valeur à coder.

        \begin{center}
        \begin{tikzpicture}[scale=1]
            \draw (0,0) -- (11,0);
            \foreach \i in {0,1,...,11}{
                \draw[dashed,black!60] (\i,-1.3) -- (\i,1.5);
            }
            \foreach \i in {0,1,4,6,7,8,10}{
                \node at (\i+0.5,1.5) {\small 0};
            }
            \foreach \i in {2,3,5,9}{
                \node at (\i+0.5,1.5) {\small 1};
            }
            \draw[red,thick]
                (0,1) cos (0.25,0) sin (0.5,-1) cos (0.75,0) sin (1,1)
                      cos (1.25,0) sin (1.5,-1) cos (1.75,0) sin (2,1)
                      cos (2.125,0) sin (2.25,-1) cos (2.375,0) sin (2.5,1)
                      cos (2.625,0) sin (2.75,-1) cos (2.875,0) sin (3,1)
                      cos (3.125,0) sin (3.25,-1) cos (3.375,0) sin (3.5,1)
                      cos (3.625,0) sin (3.75,-1) cos (3.875,0) sin (4,1)
                      cos (4.25,0) sin (4.5,-1) cos (4.75,0) sin (5,1)
                      cos (5.125,0) sin (5.25,-1) cos (5.375,0) sin (5.5,1)
                      cos (5.625,0) sin (5.75,-1) cos (5.875,0) sin (6,1)
                      cos (6.25,0) sin (6.5,-1) cos (6.75,0) sin (7,1)
                      cos (7.25,0) sin (7.5,-1) cos (7.75,0) sin (8,1)
                      cos (8.25,0) sin (8.5,-1) cos (8.75,0) sin (9,1)
                      cos (9.125,0) sin (9.25,-1) cos (9.375,0) sin (9.5,1)
                      cos (9.625,0) sin (9.75,-1) cos (9.875,0) sin (10,1)
                      cos (10.25,0) sin (10.5,-1) cos (10.75,0) sin (11,1)
                ;
        \end{tikzpicture}
        \end{center}

    \subsection{Modulation de phase (PSK, Phase Shift Keying)}

        On applique un déphasage pour différencier les séquences binaires par rapport à la phase de la porteuse, qui sert de référence.

        \begin{center}
        \begin{tikzpicture}[scale=1]
            \draw (0,0) -- (11,0);
            \foreach \i in {0,1,...,11}{
                \draw[dashed,black!60] (\i,-1.3) -- (\i,1.5);
            }
            \foreach \i in {0,1,4,6,7,8,10}{
                \node at (\i+0.5,1.5) {\small 0};
            }
            \foreach \i in {2,3,5,9}{
                \node at (\i+0.5,1.5) {\small 1};
            }
            \draw[red,thick]
                (0,0) sin (0.125,-1) cos (0.25,0) sin (0.375,1) cos (0.5,0)
                      sin (0.625,-1) cos (0.75,0) sin (0.875,1) cos (1,0)
                      sin (1.125,-1) cos (1.25,0) sin (1.375,1) cos (1.5,0)
                      sin (1.625,-1) cos (1.75,0) sin (1.875,1) cos (2,0)
                      sin (2.125,1) cos (2.25,0) sin (2.375,-1) cos (2.5,0)
                      sin (2.625,1) cos (2.75,0) sin (2.875,-1) cos (3,0)
                      sin (3.125,1) cos (3.25,0) sin (3.375,-1) cos (3.5,0)
                      sin (3.625,1) cos (3.75,0) sin (3.875,-1) cos (4,0)
                      sin (4.125,-1) cos (4.25,0) sin (4.375,1) cos (4.5,0)
                      sin (4.625,-1) cos (4.75,0) sin (4.875,1) cos (5,0)
                      sin (5.125,1) cos (5.25,0) sin (5.375,-1) cos (5.5,0)
                      sin (5.625,1) cos (5.75,0) sin (5.875,-1) cos (6,0)
                      sin (6.125,-1) cos (6.25,0) sin (6.375,1) cos (6.5,0)
                      sin (6.625,-1) cos (6.75,0) sin (6.875,1) cos (7,0)
                      sin (7.125,-1) cos (7.25,0) sin (7.375,1) cos (7.5,0)
                      sin (7.625,-1) cos (7.75,0) sin (7.875,1) cos (8,0)
                      sin (8.125,-1) cos (8.25,0) sin (8.375,1) cos (8.5,0)
                      sin (8.625,-1) cos (8.75,0) sin (8.875,1) cos (9,0)
                      sin (9.125,1) cos (9.25,0) sin (9.375,-1) cos (9.5,0)
                      sin (9.625,1) cos (9.75,0) sin (9.875,-1) cos (10,0)
                      sin (10.125,-1) cos (10.25,0) sin (10.375,1) cos (10.5,0)
                      sin (10.625,-1) cos (10.75,0) sin (10.875,1) cos (11,0)
                ;
        \end{tikzpicture}
        \end{center}

        On peut faire une représentation trigonométrique de ces modulations~: \emph{constellation}.

        \hfill
        \begin{tikzpicture}[scale=1.5,baseline=(current bounding box.center)]
            \node at (0,2) {BPSK (Binary PSK)};
            \draw (-1.5,0) -- (1.5,0);
            \draw (0,-1.5) -- (0,1.5);
            \draw (0,0) circle (1);
            \draw[red,fill] (1,0) circle (2pt) node[below right,black]{0};
            \draw[red,fill] (-1,0) circle (2pt) node[below left,black]{1};
            \draw[-latex] (0.3,0) arc [start angle=0,end angle=180,radius=0.3];
            \node[black!80] at (0.7,0.6) {Déphasage $\varphi=\pi$};
        \end{tikzpicture}
        \hfill
        \begin{tikzpicture}[scale=1.5,baseline=(current bounding box.center)]
            \node at (0,2) {4-PSK};
            \draw (-1.5,0) -- (1.5,0);
            \draw (0,-1.5) -- (0,1.5);
            \draw (0,0) circle (1);
            \draw[red,fill] (1,0) circle (2pt) node[below right,black]{\small 01};
            \draw[red,fill] (-1,0) circle (2pt) node[below left,black]{\small 10};
            \draw[red,fill] (0,1) circle (2pt) node[above right,black]{\small 00};
            \draw[red,fill] (0,-1) circle (2pt) node[below left,black]{\small 11};
        \end{tikzpicture}
        \hspace{0.5cm}
        \begin{tabular}{cc}
            \toprule
            \textbf{Symbole} & \textbf{Phase} \\
            \midrule
            01 & 0 \\
            \midrule
            00 & $\frac{\pi}{2}$ \\
            \midrule
            10 & $\pi$ \\
            \midrule
            11 & $\frac{3\pi}{2}$ \\
            \bottomrule
        \end{tabular}
        \hfill{}

        Plus le nombre d'état est élevé, plus la vitesse de transmission des données augmente, mais avec l'influence du bruit, plus la probabilité d'erreur est élevée.

    \subsection{Modulation combinée (MAQ-M)}

        C'est la combinaison des modulations d'amplitude et de phase.
        On la note MAQ-M, de M états de phase et d'amplitude.
        En général, $M=2^n$~: chaque symbole code $n=\log_2(M)$ bits.

        Exemple pour une MAQ-16~:

        \hfill
        \begin{tikzpicture}[scale=1.5,baseline=(current bounding box.center)]
            \draw (-2,0) -- (2,0);
            \draw (0,-2) -- (0,2);
            \draw[red,fill] (-1.5,-1.5) circle (2pt) node[below left,black]{\tiny 0000};
            \draw[red,fill] (-1.5,-0.5) circle (2pt) node[below left,black]{\tiny 0001};
            \draw[red,fill] (-1.5,1.5) circle (2pt) node[below left,black]{\tiny 0010};
            \draw[red,fill] (-1.5,0.5) circle (2pt) node[below left,black]{\tiny 0011};

            \draw[red,fill] (-0.5,-1.5) circle (2pt) node[below left,black]{\tiny 0100};
            \draw[red,fill] (-0.5,-0.5) circle (2pt) node[below left,black]{\tiny 0101};
            \draw[red,fill] (-0.5,1.5) circle (2pt) node[below left,black]{\tiny 0110};
            \draw[red,fill] (-0.5,0.5) circle (2pt) node[below left,black]{\tiny 0111};

            \draw[red,fill] (0.5,-1.5) circle (2pt) node[below right,black]{\tiny 1100};
            \draw[red,fill] (0.5,-0.5) circle (2pt) node[below right,black]{\tiny 1101};
            \draw[red,fill] (0.5,1.5) circle (2pt) node[below right,black]{\tiny 1110};
            \draw[red,fill] (0.5,0.5) circle (2pt) node[below right,black]{\tiny 1111};

            \draw[red,fill] (1.5,-1.5) circle (2pt) node[below right,black]{\tiny 1000};
            \draw[red,fill] (1.5,-0.5) circle (2pt) node[below right,black]{\tiny 1001};
            \draw[red,fill] (1.5,1.5) circle (2pt) node[below right,black]{\tiny 1010};
            \draw[red,fill] (1.5,0.5) circle (2pt) node[below right,black]{\tiny 1011};
        \end{tikzpicture}
        \hfill
        \begin{tikzpicture}[xscale=1.1,yscale=0.6,baseline=(current bounding box.center)]
            \node at (1,6.5) {\tiny Signal binaire $m(t)$};
            \draw (0,0) -- (8,0);
            \draw (0,6) -- (8,6);
            \foreach \i in {0,1,...,8}{\draw (\i,0) -- (\i,6);}
            \foreach \i in {1,2,...,5}{\draw[dashed] (0,\i) -- (8,\i);}
            \foreach \i in {0,1,1.5,2,2.5,3.5,4,7,7.5}{\node at (\i+0.25,5.5) {\small 0};}
            \foreach \i in {0.5,3,4.5,5,5.5,6,6.5}{\node at (\i+0.25,5.5) {\small 1};}
            \draw[red,thick]
                (0,1) -- (0.5,1) -- (0.5,5) -- (1,5) -- (1,1) -- (3,1) -- (3,5) --
                (3.5,5) -- (3.5,1) -- (4.5,1) -- (4.5,5) -- (7,5) -- (7,1) -- (8,1)
                ;
        \end{tikzpicture}

        \hfill
        \begin{tikzpicture}[xscale=1.1,yscale=0.4]
            \node at (1.2,5.6) {\tiny Signal modulé $s_{mod}(t)$};
            \draw (0,-5) -- (8,-5);
            \draw (0,5) -- (8,5);
            \foreach \i in {0,1,...,8}{\draw (\i,-5) -- (\i,5);}
            \foreach \i in {-4,-3,...,4}{\draw[dashed] (0,\i) -- (8,\i);}
            \draw[red] (0,0)
                \foreach \i in {0,0.1,...,2}{
                    sin (\i+0.025,3) cos (\i+0.05,0) sin (\i+0.075,-3) cos (\i+0.1,0)
                }
                \foreach \i in {2,2.1,...,4}{
                    sin (\i+0.025,4) cos (\i+0.05,0) sin (\i+0.075,-4) cos (\i+0.1,0)
                }
                \foreach \i in {4,4.1,...,6}{
                    sin (\i+0.025,1) cos (\i+0.05,0) sin (\i+0.075,-1) cos (\i+0.1,0)
                }
                \foreach \i in {6,6.1,...,8}{
                    sin (\i+0.025,2) cos (\i+0.05,0) sin (\i+0.075,-2) cos (\i+0.1,0)
                }
                ;
        \end{tikzpicture}

\section{Synchronisation dans les récepteurs}

    Le récepteur reçoit un signal retardé par rapport à l'émission.
    Il doit également mesurer le temps grâce à une horloge pour échantillonner le signal reçu.
    Pour récupérer correctement le signal émis, il faut que le récepteur se synchronise sur l'émetteur.

    \begin{itemize}

        \item supposons que le signal de départ soit de la forme $y(t) = A_y\cos(\omega_0 t + \theta(t))$

        \item à l'arrivée, la forme est analogique~: $v(t) = A_v\cos(\omega_0 t + \varphi(t))$

        \item le détecteur de phase engendre le signal $\varepsilon(t) = f(\theta(t) - \varphi(t))$

    \end{itemize}

    La fonction $f$ est donc une fonction en \emph{dents de scie}.

    Si la boucle à verrouillage de phase est stable et réagit rapidement et que les fluctuations $\theta(t)$ ne sont pas trop grandes, alors $v(t)$ suivra assez bien $y(t)$.

    Cette boucle à verrouillage de phase sert premièrement à récupérer la phase de la fréquence porteuse.

    \paragraph{Impacts d'une mauvaise synchronisation}

        \begin{enumerate}
            \item Erreur sur la phase ---
                Une perturbation sur la phase entraîne une rotation de la constellation, qu'il est possible de compenser.
            \item Erreur sur le rythme ---
                Une erreur sur l'instant d'échantillonnage provoque de l'IIS\@.
        \end{enumerate}

\section{Principe de l'embrouillage (scrambling)}

    L'embrouillage sert à maintenir des caractéristiques spectrales et statistiques du signal à transmettre proches de celles de la théorie (Bennett, voir~\ref{par:bennett}). \\
    Il s'agit aussi de maintenir la synchronisation du récepteur même en l'absence du signal à transmettre.

    Cela consiste à mélanger au même rythme d'horloge, par un \texttt{XOR}, le signal à transmettre $\{s_i\}$ avec une séquence pseudo-aléatoire $\{e_i\}$, réalisée à l'aide d'un registre à décalages.

    \begin{itemize}

        \item à l'émission~:
            \begin{equation*}
                t_1 = s_i \oplus e_i \quad \text{avec} \quad e_i = \sum_{j=1}^{n} h_j t_j
            \end{equation*}

        \item à la réception~:
            \begin{equation*}
                d_i = t_1 \oplus e_i = s_i \oplus (e_i \oplus e_i) = s_i
            \end{equation*}

    \end{itemize}

\section{Étalement de spectre}

\end{document}
