884 lines
32 KiB
TeX
884 lines
32 KiB
TeX
\documentclass[a4paper,french,12pt]{article}
|
|
|
|
\title{Logique Programmable}
|
|
\author{}
|
|
\date{Dernière compilation~: \today{} à \currenttime}
|
|
|
|
\usepackage{../cours}
|
|
|
|
\begin{document}
|
|
|
|
\maketitle
|
|
\tableofcontents
|
|
|
|
\clearpage
|
|
|
|
\section{Pré-requis}
|
|
|
|
\subsection{Algèbre de Boole}
|
|
|
|
\subsubsection{Logique booléenne}
|
|
|
|
Un composant discret n'a pas plus de 4 portes en alimentation continue.
|
|
7400 (gamme commerciale) ou 5400 (gamme militaire)
|
|
2 entrées et 1 sortie (3 broches) * 4 portes = 12 broches
|
|
|
|
Plusieurs technologies sont possibles~:
|
|
|
|
\begin{itemize}
|
|
|
|
\item chimique
|
|
|
|
\item hydraulique
|
|
|
|
\item pneumatique
|
|
|
|
\item mécanique
|
|
|
|
\item électromécanique
|
|
|
|
\item électrique
|
|
|
|
\item électronique (ce qui nous intéresse)
|
|
|
|
\end{itemize}
|
|
|
|
On détermine un état bas et un état haut~:
|
|
|
|
\begin{itemize}
|
|
|
|
\item état bas < tension VIL (input low)
|
|
|
|
\item état haut > tension VIH (input high)
|
|
|
|
\end{itemize}
|
|
|
|
Quand on passe de l'un à l'autre, c'est pour une très courte période.
|
|
|
|
Pour les fonctions de base, voir \url{http://www.futurlec.com/IC74LS00Series.shtml}
|
|
|
|
Avec \texttt{AND} et \texttt{OR} on peut fabriquer toutes les briques possibles.
|
|
|
|
En notation booléenne~:
|
|
|
|
\begin{itemize}
|
|
|
|
\item H (high) = 1 = vrai
|
|
|
|
\item L (low) = 0 = faux
|
|
|
|
\end{itemize}
|
|
|
|
\paragraph{Suiveur}
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\includegraphics[width=0.2\linewidth]{./img/suiveur.png}
|
|
|
|
La sortie est égale à l'entrée ($S = E$).
|
|
|
|
\end{multicols}
|
|
|
|
|
|
\begin{center}
|
|
|
|
Table de vérité~:
|
|
|
|
\begin{tabular}{c|c}
|
|
E & S \\
|
|
\midrule
|
|
L & L \\
|
|
H & H \\
|
|
\end{tabular}
|
|
|
|
\end{center}
|
|
|
|
\paragraph{Inverseur}
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\includegraphics[width=0.2\linewidth]{./img/inverseur.png}
|
|
|
|
La sortie est l'inverse de l'entrée ($S = \bar{E}$).
|
|
|
|
\end{multicols}
|
|
|
|
\begin{center}
|
|
|
|
Table de vérité~:
|
|
|
|
\begin{tabular}{c|c}
|
|
E & S \\
|
|
\midrule
|
|
L & H \\
|
|
H & L \\
|
|
\end{tabular}
|
|
|
|
\end{center}
|
|
|
|
\paragraph{OU logique --- \texttt{OR} ($+$)}
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\includegraphics[width=0.2\linewidth]{./img/or.png}
|
|
|
|
\columnbreak{}
|
|
|
|
Pour que $S$ soit vrai il suffit qu'\emph{une seule} entrée soit vraie.
|
|
|
|
Pour que $S$ soit faux il faut que \emph{toutes} les entrées soient fausses.
|
|
|
|
\end{multicols}
|
|
|
|
\begin{center}
|
|
|
|
Tables de vérité~:
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\begin{tabular}{c|c|c}
|
|
$E_1$ & $E_2$ & $E_1 + E_2$ \\
|
|
\midrule
|
|
0 & 0 & 0 \\
|
|
0 & 1 & 1 \\
|
|
1 & 0 & 1 \\
|
|
\end{tabular}
|
|
|
|
\begin{tabular}{c|c|c}
|
|
X & Y & S \\
|
|
\midrule
|
|
L & L & L \\
|
|
L & H & H \\
|
|
H & L & H \\
|
|
H & H & H \\
|
|
\end{tabular}
|
|
|
|
\end{multicols}
|
|
|
|
\end{center}
|
|
|
|
\begin{align*}
|
|
a + 0 &= a \\
|
|
a + 1 &= 1 \\
|
|
a + a &= a \\
|
|
a + \bar{a} &= 1 \\
|
|
\end{align*}
|
|
|
|
\paragraph{ET logique --- \texttt{AND} ($\cdot$)}
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\includegraphics[width=0.2\linewidth]{./img/and.png}
|
|
|
|
C'est l'inverse du OU\@.
|
|
Pour que $S$ soit vrai il faut que toutes les entrées soient vraies.
|
|
|
|
\end{multicols}
|
|
|
|
\begin{center}
|
|
|
|
Tables de vérité~:
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\begin{tabular}{c|c|c}
|
|
$E_1$ & $E_2$ & $E_1 \cdot E_2$ \\
|
|
0 & 0 & 0 \\
|
|
0 & 1 & 0 \\
|
|
1 & 0 & 0 \\
|
|
1 & 1 & 1 \\
|
|
\end{tabular}
|
|
|
|
\columnbreak{}
|
|
|
|
\begin{tabular}{c|c|c}
|
|
X & Y & S \\
|
|
\midrule
|
|
L & L & L \\
|
|
L & H & L \\
|
|
H & L & L \\
|
|
H & H & H \\
|
|
\end{tabular}
|
|
|
|
\end{multicols}
|
|
|
|
\end{center}
|
|
|
|
\paragraph{OU exclusif --- \texttt{XOR} ($\oplus$)}
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\includegraphics[width=0.2\linewidth]{./img/xor.png}
|
|
|
|
Pour que $S$ soit vrai il faut \emph{soit} que $E_1$ soit vrai \emph{soit} que $E_2$ soit vrai.
|
|
|
|
\end{multicols}
|
|
|
|
\begin{center}
|
|
|
|
Tables de vérité~:
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\begin{tabular}{c|c|c}
|
|
$E_1$ & $E_2$ & $E_1 \oplus E_2$ \\
|
|
\midrule
|
|
0 & 0 & 0 \\
|
|
0 & 1 & 1 \\
|
|
1 & 0 & 1 \\
|
|
1 & 1 & 0 \\
|
|
\end{tabular}
|
|
|
|
\begin{tabular}{c|c|c}
|
|
X & Y & S \\
|
|
\midrule
|
|
L & L & L \\
|
|
L & H & H \\
|
|
H & L & H \\
|
|
H & H & L \\
|
|
\end{tabular}
|
|
|
|
\end{multicols}
|
|
|
|
\end{center}
|
|
|
|
\begin{align*}
|
|
a \oplus 0 &= a \\
|
|
a \oplus 1 &= \bar{a} \\
|
|
a \oplus a &= 0 \\
|
|
a \oplus \bar{a} &= 1 \\
|
|
\end{align*}
|
|
|
|
\paragraph{Non OU --- \texttt{NOR} ($\overline{+}$)}
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\includegraphics[width=0.2\linewidth]{./img/nor.png}
|
|
|
|
Pour que $S$ soit vrai, il faut que $E_1$ et $E_2$ soient faux.
|
|
|
|
\end{multicols}
|
|
|
|
Théorême de Morgan~: $\overline{a + b} = \bar{a} \cdot \bar{b}$
|
|
|
|
\begin{center}
|
|
|
|
Tables de vérité~:
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\begin{tabular}{c|c|c}
|
|
$E_1$ & $E_2$ & $\overline{E_1 + E_2}$ \\
|
|
\midrule
|
|
0 & 0 & 1 \\
|
|
0 & 1 & 0 \\
|
|
1 & 0 & 0 \\
|
|
1 & 1 & 0 \\
|
|
\end{tabular}
|
|
|
|
\begin{tabular}{c|c|c}
|
|
X & Y & S \\
|
|
\midrule
|
|
L & L & H \\
|
|
L & H & L \\
|
|
H & L & L \\
|
|
H & H & L \\
|
|
\end{tabular}
|
|
|
|
\end{multicols}
|
|
|
|
\end{center}
|
|
|
|
\paragraph{Non ET --- \texttt{NAND} ($\overline{\cdot}$)}
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\includegraphics[width=0.2\linewidth]{./img/nand.png}
|
|
|
|
Pour que $S$ soit vrai il suffit qu'entrée soit fausse.
|
|
|
|
\end{multicols}
|
|
|
|
Théorême de Morgan~: $\overline{a \cdot b} = \bar{a} + \bar{b}$
|
|
|
|
\begin{center}
|
|
|
|
Tables de vérité~:
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\begin{tabular}{c|c|c}
|
|
$E_1$ & $E_2$ & $\overline{E_1 \cdot E_2}$ \\
|
|
\midrule
|
|
0 & 0 & 1 \\
|
|
0 & 1 & 1 \\
|
|
1 & 0 & 1 \\
|
|
1 & 1 & 0 \\
|
|
\end{tabular}
|
|
|
|
\begin{tabular}{c|c|c}
|
|
X & Y & S \\
|
|
\midrule
|
|
L & L & H \\
|
|
L & H & H \\
|
|
H & L & H \\
|
|
H & H & L \\
|
|
\end{tabular}
|
|
|
|
\end{multicols}
|
|
|
|
\end{center}
|
|
|
|
\paragraph{Non OU exclusif --- \texttt{NO XOR} ($\overline{\oplus}$)}
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\includegraphics[width=0.2\linewidth]{./img/xnor.png}
|
|
|
|
Pour que $S$ soit vrai il faut que les entrées soient identiques.
|
|
|
|
\end{multicols}
|
|
|
|
\begin{center}
|
|
|
|
Tables de vérité~:
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\begin{tabular}{c|c|c}
|
|
$E_1$ & $E_2$ & $\overline{E_1 \oplus E_2}$ \\
|
|
\midrule
|
|
0 & 0 & 1 \\
|
|
0 & 1 & 0 \\
|
|
1 & 0 & 0 \\
|
|
1 & 1 & 1 \\
|
|
\end{tabular}
|
|
|
|
\begin{tabular}{c|c|c}
|
|
X & Y & S \\
|
|
\midrule
|
|
L & L & H \\
|
|
L & H & L \\
|
|
H & L & L \\
|
|
H & H & H \\
|
|
\end{tabular}
|
|
|
|
\end{multicols}
|
|
|
|
\end{center}
|
|
|
|
\subsubsection{Algèbre booléenne}
|
|
|
|
Le ET est prioritaire sur le OU\@.
|
|
|
|
\begin{tabularx}{\linewidth}{XX}
|
|
\toprule
|
|
\multirow{2}{*}{élément neutre} & $a \cdot 1 = a$ \\
|
|
& $a + 0 = a$ \\
|
|
\midrule
|
|
\multirow{2}{*}{élément absorbant} & $a \cdot 0 = 0$ \\
|
|
& $a + 1 = 1$ \\
|
|
\midrule
|
|
\multirow{2}{*}{idempotence} & $a \cdot a = a$ \\
|
|
& $a + a = a$ \\
|
|
\midrule
|
|
\multirow{2}{*}{complément} & $a \cdot \bar{a} = 0$ \\
|
|
& $a + \bar{a} = 1$ \\
|
|
\midrule
|
|
\multirow{2}{*}{commutativité} & $a \cdot b = b \cdot a$ \\
|
|
& $a + b = b + a$ \\
|
|
\midrule
|
|
\multirow{2}{*}{associativité} & $a \cdot (b \cdot c) = (a \cdot b) \cdot c = a \cdot b \cdot c$ \\
|
|
& $a + (b + c) = (a + b) + c = a + b + c$ \\
|
|
\midrule
|
|
\multirow{2}{*}{distributivité} & $a \cdot (b + c) = (a \cdot b) + (a \cdot c) = a \cdot b + a \cdot c$ \\
|
|
& $a + (b \cdot c) = (a + b) \cdot (a + c)$ \\
|
|
\midrule
|
|
\multirow{2}{*}{théorême de Morgan} & $\overline{a \cdot b} = \bar{a} + \bar{b}$ \\
|
|
& $\overline{a + b} = \bar{a} \cdot \bar{b}$ \\
|
|
\midrule
|
|
\multirow{2}{*}{consensus} & $a \cdot b + \bar{a} \cdot c + b \cdot c = a \cdot b + \bar{a} \cdot c$ \\
|
|
& $(a + b) \cdot (\bar{a} + c) \cdot (b + c) = (a + b) \cdot (\bar{a} + c)$ \\
|
|
\midrule
|
|
\multirow{2}{*}{consensus généralisé} & $a \cdot b + \bar{a} \cdot c + b \cdot c \cdot d = a \cdot b + \bar{a} \cdot c$ \\
|
|
& $(a + b) \cdot (\bar{a} + c) \cdot (b + c + d) = (a + b) \cdot (\bar{a} + c)$ \\
|
|
\midrule
|
|
\multirow{2}{*}{fonction biforme} & $a \cdot b + \bar{a} \cdot c = (a + c) \cdot (\bar{a} + b)$ \\
|
|
& $(a + b) \cdot (\bar{a} + c) = (a \cdot c) + (\bar{a} \cdot b)$ \\
|
|
\bottomrule
|
|
\end{tabularx}
|
|
|
|
\subsubsection{Fonctions booléennes}
|
|
|
|
On cherche à simplifier les fonctions pour limiter le nombre de portes logiques utilisées.
|
|
|
|
Une fonction booléenne est une application de $\{0,1\}^n$ dans $\{0,1\}$.
|
|
|
|
$x_1, x_2, \dots, x_n \rightarrow{} y = f(x_1, x_2, \dots, x_n)$
|
|
|
|
\begin{center}
|
|
|
|
\begin{multicols}{2}
|
|
|
|
Elle peut être écrite par une table~:
|
|
|
|
\begin{tabular}{cccc}
|
|
$x_2$ & $x_1$ & $x_0$ & $y$ \\
|
|
\midrule
|
|
0 & 0 & 0 & 0 \\
|
|
0 & 0 & 1 & 1 \\
|
|
0 & 1 & 0 & 0 \\
|
|
0 & 1 & 1 & 1 \\
|
|
1 & 0 & 0 & 0 \\
|
|
1 & 0 & 1 & 0 \\
|
|
1 & 1 & 0 & 1 \\
|
|
1 & 1 & 1 & 1 \\
|
|
\end{tabular}
|
|
|
|
\columnbreak{}
|
|
|
|
ou par une expression~:
|
|
|
|
$y = f(x_2,x_1,x_0) = x_2 \cdot x_1 + \overline{x_2} \cdot x_0$.
|
|
|
|
\end{multicols}
|
|
|
|
\end{center}
|
|
|
|
\paragraph{Minterme, maxterme}
|
|
|
|
Soit $f(x,y,z)$.
|
|
|
|
$\bar{x} \cdot y$ est un minterme.
|
|
|
|
$x \cdot y \cdot \bar{z}$ est un minterme complet.
|
|
|
|
$\bar{x} + y$ est un maxterme.
|
|
|
|
$x + y + \bar{z}$ est un maxterme complet.
|
|
|
|
\begin{tabular}{ccc|cc}
|
|
\toprule
|
|
x & y & z & minterme associé & maxterme associé \\
|
|
\midrule
|
|
0 & 0 & 0 & $\bar{x} \cdot \bar{y} \cdot \bar{z}$ & $x + y + z$ \\
|
|
0 & 1 & 1 & $\bar{x} \cdot y \cdot z$ & $x + \bar{y} + \bar{z}$ \\
|
|
1 & 0 & 1 & $x \cdot \bar{y} \cdot z$ & $\bar{x} + y + \bar{z}$ \\
|
|
1 & 1 & 1 & $x \cdot y \cdot z$ & $\bar{x} + \bar{y} + \bar{z}$ \\
|
|
\bottomrule
|
|
\end{tabular}
|
|
|
|
\paragraph{Première forme canonique --- Forme disjonctive}
|
|
|
|
On peut dire qu'une fonction est le OU logique des mintermes associés aux vecteurs pour lesquels la fonction vaut 1.
|
|
Par exemple~:
|
|
|
|
\begin{center}
|
|
|
|
\begin{tabular}{ccc|l}
|
|
|
|
\toprule
|
|
$x$ & $y$ & $z$ & $f(x, y, z)$ \\
|
|
\toprule
|
|
0 & 0 & 0 & 0 \\
|
|
\midrule
|
|
0 & 0 & 1 & 1 $\quad \rightarrow \quad$ minterme associé~: $\quad \bar{x} \cdot \bar{y} \cdot z$ \\
|
|
\midrule
|
|
0 & 1 & 0 & 0 \\
|
|
\midrule
|
|
0 & 1 & 1 & 1 $\quad \rightarrow \quad$ minterme associé~: $\quad \bar{x} \cdot y \cdot z$ \\
|
|
\midrule
|
|
1 & 0 & 0 & 0 \\
|
|
\midrule
|
|
1 & 0 & 1 & 0 \\
|
|
\midrule
|
|
1 & 1 & 0 & 1 $\quad \rightarrow \quad$ minterme associé~: $\quad x \cdot y \cdot \bar{z}$ \\
|
|
\midrule
|
|
1 & 1 & 1 & 1 $\quad \rightarrow \quad$ minterme associé~: $\quad x \cdot y \cdot z$ \\
|
|
\bottomrule
|
|
|
|
\end{tabular}
|
|
|
|
$f(x, y, z) = \bar{x} \cdot \bar{y} \cdot z + \bar{x} \cdot y \cdot z + x \cdot y \cdot \bar{z} + x \cdot y \cdot z$
|
|
|
|
\end{center}
|
|
|
|
\paragraph{Deuxième forme canonique --- Forme conjonctive}
|
|
|
|
On peut aussi dire que la fonction est le ET logique des maxtermes associés aux vecteurs pour lesquels la fonction vaut 0.
|
|
Avec le même exemple~:
|
|
|
|
\begin{center}
|
|
|
|
\begin{tabular}{ccc|l}
|
|
|
|
\toprule
|
|
$x$ & $y$ & $z$ & $f(x, y, z)$ \\
|
|
\toprule
|
|
0 & 0 & 0 & 0 $\quad \rightarrow \quad$ maxterme associé~: $\quad x + y + z$ \\
|
|
\midrule
|
|
0 & 0 & 1 & 1 \\
|
|
\midrule
|
|
0 & 1 & 0 & 0 $\quad \rightarrow \quad$ maxterme associé~: $\quad x + \bar{y} + z$ \\
|
|
\midrule
|
|
0 & 1 & 1 & 1 \\
|
|
\midrule
|
|
1 & 0 & 0 & 0 $\quad \rightarrow \quad$ maxterme associé~: $\quad \bar{x} + y + z$ \\
|
|
\midrule
|
|
1 & 0 & 1 & 0 $\quad \rightarrow \quad$ maxterme associé~: $\quad \bar{x} + y + \bar{z}$ \\
|
|
\midrule
|
|
1 & 1 & 0 & 1 \\
|
|
\midrule
|
|
1 & 1 & 1 & 1 \\
|
|
\bottomrule
|
|
|
|
\end{tabular}
|
|
|
|
$f(x, y, z) = (x + y + z) \cdot (x + \bar{y} + z) \cdot (\bar{x} + y + z) \cdot (\bar{x} + y + \bar{z})$
|
|
|
|
\end{center}
|
|
|
|
\paragraph{Simplification des fonctions booléennes --- Tableau de Karnaugh}
|
|
|
|
Soit $S$ la fonction définie par le tableau de vérité et l'expression suivants~:
|
|
|
|
\begin{tabular}{r|ccc|c}
|
|
\toprule
|
|
valeur décimale & $x_2$ & $x_1$ & $x_0$ & $S$ \\
|
|
\midrule
|
|
0 & 0 & 0 & 0 & 0 \\
|
|
1 & 0 & 0 & 1 & 0 \\
|
|
2 & 0 & 1 & 0 & 1 \\
|
|
3 & 0 & 1 & 1 & 1 \\
|
|
4 & 1 & 0 & 0 & 1 \\
|
|
5 & 1 & 0 & 1 & 1 \\
|
|
6 & 1 & 1 & 0 & 1 \\
|
|
7 & 1 & 1 & 1 & 0 \\
|
|
\bottomrule
|
|
\end{tabular}
|
|
|
|
$S = \overline{x_2} \cdot x_1 \cdot \overline{x_0} + \overline{x_2} \cdot x_1 \cdot x_0 + x_2 \cdot \overline{x_1} \cdot \overline{x_0} + x_2 \cdot \overline{x_1} \cdot x_0 + x_2 \cdot x_1 \cdot \overline{x_0}$
|
|
|
|
On peut simplifier l'expression~:
|
|
|
|
\begin{align*}
|
|
\overline{x_2} \cdot x_1 \cdot \overline{x_0} + \overline{x_2} \cdot x_1 \cdot x_0
|
|
&= \overline{x_2} \cdot x_1 \cdot (\overline{x_0} + \cdot x_0) \\
|
|
&= \overline{x_2} \cdot x_1 \cdot 1 \\
|
|
&= \overline{x_2} \cdot x_1 \\
|
|
\end{align*}
|
|
|
|
On a regroupé deux mintermes différents par la complémentation d'une variable.
|
|
Un \emph{tableau de Karnaugh} permet de faire cela de manière systématique.
|
|
|
|
Pour créer un tableau de Karnaugh, on reproduit une table de vérité sous forme d'un tableau à double entrée selon le code Gray (un seul bit change entre deux entrées adjacentes).
|
|
|
|
Exemple~:
|
|
|
|
\begin{multicols}{2}
|
|
|
|
$G = \overline{x_2} \cdot x_1 \cdot \overline{x_0} + \overline{x_2} \cdot x_1 \cdot x_0$
|
|
|
|
\begin{tabular}{|c|c|c|c|c|}
|
|
\hline
|
|
$x_2\backslash x_1 x_0$ & 00 & 01 & 11 & 10 \\
|
|
\hline
|
|
0 & $0_0$ & $0_1$ & $\textcolor{red}{1}_3$ & $\textcolor{red}{1}_2$ \\
|
|
\hline
|
|
1 & $0_4$ & $0_5$ & $0_7$ & $0_6$ \\
|
|
\hline
|
|
\end{tabular}
|
|
|
|
\end{multicols}
|
|
|
|
Pour chaque minterme correspondant à deux cases adjacentes à 1 du tableau, il suffit alors de recopier seulement les variables qui ne changent pas~:
|
|
|
|
$G = \overline{x_2} \cdot x_1 \cdot (\overline{x_0} + x_0) = \overline{x_2} \cdot x_1$
|
|
\quad (ici $x_0$ change et donc s'annule)
|
|
|
|
On peut ainsi regrouper 2, 4 voire 8 cases (= 1, 2 ou 3 mintermes).
|
|
|
|
\subsection{Logique combinatoire}
|
|
|
|
\subsubsection{Les codeurs}
|
|
|
|
Un codeur possède $2^n$ entrées pour $n$ sorties.
|
|
Donc 8 entrées pour 3 sorties, 4 entrées pour 2 sorties, etc.
|
|
|
|
Une seule entrée ne peut être active (mise à 1) à la fois.
|
|
Le codeur code en binaire le numéro décimal de l'entrée active.
|
|
|
|
Par exemple, pour un codeur en 8$\times$3, si l'entrée n°$6_{10}$ est activée à 1, la sortie vaudra $110_2$.
|
|
|
|
\begin{center}
|
|
\includegraphics[width=0.3\textwidth]{./img/codeur.png}
|
|
\end{center}
|
|
|
|
\subsubsection{Encodeur de priorité}
|
|
|
|
Même principe que le pour le codeur, mais plusieurs entrées peuvent être actives en même temps.
|
|
Dans ce cas, on décide d'un ordre de priorité, et l'encodeur s'arrête de lire les entrées quand il rencontre l'entrée active la plus prioritaire.
|
|
|
|
Par exemple, avec $I_3, I_2, I_1, I_0$ en entrée et par ordre de priorité et $S_1, S_0$ en sortie~:
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\includegraphics[width=0.2\textwidth]{./img/encodeur-de-priorite.png}
|
|
|
|
\begin{tabular}{cccc|cc|c}
|
|
\toprule
|
|
\multicolumn{4}{c|}{Entrées} & \multicolumn{3}{c}{Sortie} \\
|
|
$I_3$ & $I_2$ & $I_1$ & $I_0$ & $S_1$ & $S_0$ & $V$ \\
|
|
\midrule
|
|
H & $\times$ & $\times$ & $\times$ & H & H & H \\
|
|
L & H & $\times$ & $\times$ & H & L & H \\
|
|
L & L & H & $\times$ & L & H & H \\
|
|
L & L & L & H & L & L & H \\
|
|
L & L & L & L & $\times$ & $\times$ & L \\
|
|
\bottomrule
|
|
\end{tabular}
|
|
|
|
\end{multicols}
|
|
|
|
$\times$~: peu importe la valeur.
|
|
|
|
La colomne $V$ (validation) indique au système l'interruption à traiter.
|
|
Elle est active quand une entrée à été lue.
|
|
|
|
\subsubsection{Décodeurs d'adresses}
|
|
|
|
Il se comporte à l'inverse du codeur.
|
|
Il lit l'entrée en binaire, puis active la sortie correspondant à la valeur décimale correspondante~:
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\includegraphics[width=0.2\textwidth]{./img/decodeur-adresses.png}
|
|
|
|
\begin{tabular}{cc|cccc}
|
|
\toprule
|
|
$A_1$ & $A_0$ & $Y_0$ & $Y_1$ & $Y_2$ & $Y_3$ \\
|
|
\midrule
|
|
L & L & H & L & L & L \\
|
|
L & H & L & H & L & L \\
|
|
H & L & L & L & H & L \\
|
|
H & H & L & L & L & H \\
|
|
\bottomrule
|
|
\end{tabular}
|
|
|
|
\end{multicols}
|
|
|
|
\subsubsection{Décodeur 7 segments}
|
|
|
|
Il est utilisé pour les horloges numériques.
|
|
|
|
\begin{center}
|
|
\includegraphics[width=0.3\textwidth]{./img/decodeur-sept-segments.png}
|
|
\end{center}
|
|
|
|
Il suffit de programmer quelles DELs en sortie vont s'allumer par rapport aux entrées binaires.
|
|
|
|
\subsubsection{Multiplexeurs}
|
|
|
|
Aux entrées s'ajoutent des signaux de sélection, qui indiquent quelle donnée sera transmise en sortie.
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\includegraphics[width=0.2\textwidth]{./img/multiplexeur.png}
|
|
|
|
\begin{tabular}{c|cc|c}
|
|
\toprule
|
|
& $S_1$ & $S_0$ & Y \\
|
|
\midrule
|
|
0 & L & L & $D_0$ \\
|
|
1 & L & H & $D_1$ \\
|
|
2 & H & L & $D_2$ \\
|
|
3 & H & H & $D_3$ \\
|
|
\bottomrule
|
|
\end{tabular}
|
|
|
|
\end{multicols}
|
|
|
|
\paragraph{Multiplexeur générateur de fonction logique}
|
|
|
|
Un multiplexeur peut être représenté par une fonction logique~:
|
|
|
|
$F(x_3, x_2, x_1, x_0) = \sum{(0, 1, 2, 4, 5, 8, 10)}$
|
|
|
|
\begin{multicols}{2}
|
|
|
|
avec 4 entrées de sélection~:
|
|
|
|
\includegraphics[width=0.3\textwidth]{./img/multiplexeur-fonction-logique.png}
|
|
|
|
\end{multicols}
|
|
|
|
\begin{multicols}{2}
|
|
|
|
avec 3 entrées de sélection~:
|
|
|
|
\includegraphics[width=0.4\textwidth]{./img/multiplexeur-fonction-logique-bis.png}
|
|
|
|
\end{multicols}
|
|
|
|
\begin{multicols}{2}
|
|
|
|
avec 2 entrées de sélection~:
|
|
|
|
\includegraphics[width=0.4\textwidth]{./img/multiplexeur-fonction-logique-ter.png}
|
|
|
|
\end{multicols}
|
|
|
|
\subsubsection{Démultiplexeurs}
|
|
|
|
Même chose dans l'autre sens~: une entrée (et des entrées de sélection) et plusieurs sorties, correspondant aux représentations décimales des entrées de sélection pour choisir sur quel canal envoyer l'entrée.
|
|
|
|
\begin{tabularx}{\linewidth}{Y|Y|YY|YYYY}
|
|
\toprule
|
|
& Entrée & \multicolumn{2}{c|}{Entrées de sélection} & \multicolumn{4}{c}{Sorties} \\
|
|
& G & $A_1$ & $A_0$ & $Y_0$ & $Y_1$ & $Y_2$ & $Y_3$ \\
|
|
\midrule
|
|
0 & L & L & L & L & H & H & H \\
|
|
1 & L & L & H & H & L & H & H \\
|
|
2 & L & H & L & H & H & L & H \\
|
|
3 & L & H & H & H & H & H & L \\
|
|
& H & $\times$ & $\times$ & H & H & H & H \\
|
|
\bottomrule
|
|
\end{tabularx}
|
|
|
|
\subsection{Logique séquentielle}
|
|
|
|
En logique combinatoire, à chaque instant, les sorties ne dépendent que des entrées.
|
|
|
|
En logique séquentielle, les sorties dépendent des entrées et de l'état dans lequel le système se trouvait à l'instant précédent.
|
|
On parle alors d'effet mémoire car le système garde en mémoire l'état précédent, ce qui est réalisé par une rétroaction de la ou des sorties sur l'entrée grâce au temps de propagation des signaux.
|
|
|
|
\subsubsection{Les bascules}
|
|
|
|
\paragraph{La bascule asynchrone RS}
|
|
|
|
Table de vérité~:
|
|
|
|
$R =$ Reset, $S =$ Set
|
|
|
|
\begin{tabular}{cc|l}
|
|
\toprule
|
|
$R_t$ & $S_t$ & $Q_t$ \\
|
|
\midrule
|
|
1 & 0 & 0 \\
|
|
0 & 1 & 1 \\
|
|
0 & 0 & $Q_{t-1}$ (mémoire) \\
|
|
1 & 1 & ces entrées ne peuvent pas être actives en même temps \\
|
|
\bottomrule
|
|
\end{tabular}
|
|
|
|
Chronogramme~:
|
|
|
|
\begin{center}
|
|
\includegraphics[width=0.8\linewidth]{./img/chronogramme-rs.png}
|
|
\end{center}
|
|
|
|
\paragraph{La bascule synchrone D}
|
|
|
|
La sortie recopie l'entrée D lorsque le signal de synchronisation est actif.
|
|
|
|
\begin{multicols}{2}
|
|
|
|
\textbf{Bascule D Latch} (sur niveau)
|
|
|
|
\includegraphics[width=0.4\linewidth]{./img/bascule-d-latch.png}
|
|
|
|
\columnbreak
|
|
|
|
\textbf{Bascule D Edge Trigger} (sur front)
|
|
|
|
\includegraphics[width=0.4\linewidth]{./img/bascule-d-edge-trigger.png}
|
|
|
|
\end{multicols}
|
|
|
|
Chronogrammes~:
|
|
|
|
\begin{center}
|
|
\includegraphics[width=\linewidth]{./img/chronogramme-d.png}
|
|
\end{center}
|
|
|
|
\paragraph{La bascule synchrone JK}
|
|
|
|
\clearpage
|
|
|
|
\section{Register Transfer Level (RTL)}
|
|
|
|
Le RTL est le niveau au dessus des couches physiques et logique, mais en dessous des couches algorithmique de haut niveau.
|
|
|
|
Jusque dans les années 1970, les circuits électroniques étaient faits à la main.
|
|
Avec l'apparition de l'Electronic Design Automation (EDA), il a fallu automatiser.
|
|
On a pu créer des puces, c'est-à-dire des circuits plus petits et denses.
|
|
|
|
Au niveau Algorithmique on s'intéresse au côté fonctionnel de ce qu'on cherche à faire.
|
|
|
|
Quand on passe au niveau RTL, on cherche à savoir combien de portes logiques on veut, quelles sont les contraintes.
|
|
|
|
Au niveau encore en dessous, on va déterminer le routage des portes et puis leur fabrication.
|
|
|
|
L'ingénieur / designer s'occupe des couches Algorithmique et RTL, tout le bas sera automatisé par EDA\@.
|
|
Pour cela il a besoin de feedback.
|
|
Il va donc considérer des contraintes que le logiciel EDA pourra prendre en compte pour indiquer si elles ont été respectées ou pas.
|
|
On peut choisir ses contraintes, par exemple consommation, taille de puce, ressources, temps\ldots
|
|
|
|
Pour programmer au niveau RTL on va utiliser un langage descriptif, le VHSIC Hardware Description Language (VHDL), qui fonctionne en logique séquentielle (opérations exécutées relativement à une horloge).
|
|
|
|
Ce langage est apparu en 1987 et destiné dans un premier temps à la simulation (pour tester les circuits avant de les fabriquer), puis à la synthèse.
|
|
|
|
\paragraph{Exemple de la bascule D}
|
|
|
|
La bascule D est séquentielle et synchrone.
|
|
|
|
\begin{itemize}
|
|
|
|
\item synchrone~: conditionné par une horloge.
|
|
|
|
\item séquentiel~: grâce à l'effet mémoire, la sortie de l'état précédent peut être réinjectée en entrée.
|
|
|
|
\end{itemize}
|
|
|
|
\paragraph{Exemple du multiplexeur}
|
|
|
|
Le multiplexeur est combinatoire et asynchrone.
|
|
Il n'utilise pas d'horloge et n'a pas de mémoire.
|
|
|
|
\subsection{VHDL - VHSIC Hardware Description Language}
|
|
|
|
\subsubsection{Modularité}
|
|
|
|
On veut de la modularité.
|
|
On va donc écrire des fichiers différents.
|
|
Le fichier appelant les autres fichiers s'appelle \texttt{top.vhd}.
|
|
Chaque sous-bloc correspond à un fichier.
|
|
|
|
\subsubsection{Signaux}
|
|
|
|
Un signal relie les blocs les uns aux autres.
|
|
|
|
\subsubsection{Concurrence}
|
|
|
|
La description implique que l'ordre dans lequel on écrit les instructions n'a pas d'importance, contrairement à une approche algorithmique.
|
|
Les différents process travaillent en parallèle.
|
|
|
|
\subsubsection{Exemple d'instanciation}
|
|
|
|
Dans \texttt{dff.vhd}, on a une entité \texttt{dff} qui décrit une bascule D\@.
|
|
|
|
Dans \texttt{top.vhd}, on a deux entités \texttt{dff\_1} et \texttt{dff\_2} qui utilisent les signaux de \texttt{dff}.
|
|
En utilsant les signaux de \texttt{dff} avec les mêmes noms, le fichier \texttt{top.vhd} connecte \texttt{dff\_1} et \texttt{dff\_2}.
|
|
|
|
\subsubsection{Machine à état (FSM)}
|
|
|
|
Une machine est efficace en logique séquentielle.
|
|
On peut donc écrire un algorithme déterministe pour faire une machine à états finis en VHDL\@.
|
|
|
|
\subsubsection{TestBench}
|
|
|
|
La modularité fait qu'on va d'abord tester chaque fichier séparément, avant de tester l'interconnection du tout dans le fichier \texttt{top.vhd}.
|
|
|
|
Pour automatiser ces tests, on écrit un fichier \texttt{exemple_tb.vhd} pour instancier les modules à tester.
|
|
|
|
\end{document}
|