You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
717 lines
27 KiB
717 lines
27 KiB
\documentclass[french]{article}
|
|
|
|
\usepackage{pgfplots}
|
|
\usepackage{tikz}
|
|
\usetikzlibrary{arrows,automata}
|
|
\usepackage{MyPack2}
|
|
|
|
\usepackage{diagbox}
|
|
\usepackage{timing}
|
|
\geometry{top=2cm, bottom=2cm, left=2cm, right=2cm}
|
|
\title{Étude de laboratoire \\ SLEA}
|
|
\author{Binôme A11 \\ \bsc{Simon} Léo, \bsc{Levy--Falk} Hugo \\ Supélec, promo 2020}
|
|
\date{\today}
|
|
|
|
\begin{document}
|
|
\maketitle
|
|
\tableofcontents
|
|
\clearpage
|
|
\initPage{TL - SLEA}{\today}{\bsc{Simon}, \bsc{Levy--Falk}}
|
|
|
|
\part{Objectifs de ce TL}
|
|
|
|
L'objectif de cette étude de laboratoire est la réalisation d'un chronomètre basique. Elle se découpe entre une étude préliminaire et la réalisation à proprement parler du chronomètre.
|
|
|
|
L'étude préliminaire permet de prendre en main le logiciel qui permettra la réalisation du chronomètre.
|
|
|
|
On dispose d'un cahier des charges pour le chronomètre. Celui-ci est constitué entre autre de deux boutons poussoirs et de deux afficheurs 7 segments. On souhaite que :
|
|
\begin{itemize}
|
|
\item Chaque appui sur \verb|START/STOP| permette de commuter entre le mode comptage (affichage du temps sur deux digits : secondes et dixièmes de seconde) et le mode arrêt (affichage du temps mémorisé);
|
|
\item Un appui sur \verb|RESET| remette l'afficheur à zéro. Cette fonction doit pouvoir être activée à tout moment et maintenir l'affichage à zéro.
|
|
\end{itemize}
|
|
|
|
Pour réaliser cela, on propose un découpage tel que montré par la figure \ref{fig:structure1}.
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=1\linewidth]{images/structure}
|
|
\caption{Découpage du projet.}
|
|
\label{fig:structure1}
|
|
\end{figure}
|
|
|
|
On consacrera donc une partie au traitement des boutons poussoirs, une au diviseur de fréquence et une au séquenceur et au chemin de donnée.
|
|
|
|
\clearpage
|
|
\part{Étude préliminaire}
|
|
|
|
Afin de prendre en main le logiciel de simulation Quartus, on simule un décodeur BCD vers 7 segments.
|
|
|
|
\section{Saisie du schéma du montage}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.7\linewidth]{images/decodeur1.PNG}
|
|
\caption{Schéma saisi}
|
|
\label{fig:decodeur1}
|
|
\end{figure}
|
|
|
|
La figure \ref{fig:decodeur1} montre le montage que nous simulerons. On commence par le compiler le projet une première fois, en utilisant le mode \verb|smart compilation|.
|
|
|
|
\section{Affectation des entrées et sorties}
|
|
En consultant la documentation de la carte \bsc{Altera} disponible sur \verb|moodle.supelec.fr|, on repère les numéros des entrées correspondants aux micro-interrupteurs à la page 12 et les numéros des sorties correspondants à l'afficheur numéro 1. On crée la table d'assignation reproduite à la figure \ref{fig:decodeur2}.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.7\linewidth]{images/decodeur2.PNG}
|
|
\caption{Assignation des I/O}
|
|
\label{fig:decodeur2}
|
|
\end{figure}
|
|
|
|
\section{Définition des vecteurs de simulation}
|
|
|
|
On crée un fichier \verb|decodeur.vwf| dans lequel on spécifie les chronogrammes imposés aux entrées. Après avoir lancé la simulation on obtient les chronogrammes de la figure \ref{fig:decodeur3}.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.7\linewidth]{images/decodeur3.PNG}
|
|
\caption{Chronogramme obtenu par simulation fonctionnelle}
|
|
\label{fig:decodeur3}
|
|
\end{figure}
|
|
|
|
\section{Simulation fonctionnelle}
|
|
|
|
On a lancé une simulation fonctionnelle, il n'y a pas d'aléas. D'autre part, page 9 de la documentation nous informe sur l'afficheur 7 segments.
|
|
|
|
\begin{quotation}
|
|
Each LED segment of the display can be illuminated by driving the connected EPM7128S device I/O pin with a logic 0. Figure 4 shows the name of each segment.
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.25\linewidth]{images/decodeurDigit.png}
|
|
\caption{Figure 4 de la documentation.}
|
|
\label{fig:decodeurDigit}
|
|
\end{figure}
|
|
|
|
\end{quotation}
|
|
|
|
On vérifie ainsi que le chronogramme correspond à l'affichage des chiffres de 0 à 9.
|
|
|
|
\section{Simulation temporelle}
|
|
|
|
On lance ensuite une simulation temporelle. La figure \ref{fig:decodeur4} montre l'apparition d'aléas dûs aux temps de propagation.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.7\linewidth]{images/decodeur4.PNG}
|
|
\caption{Simulation temporelle}
|
|
\label{fig:decodeur4}
|
|
\end{figure}
|
|
|
|
\section{Analyse temporelle}
|
|
|
|
L'analyse temporelle donne le temps de propagation entre les entrées et les sorties. La figure \ref{fig:decodeur5} montre que le temps de propagation est d'environ 30 ns.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics{images/decodeur5.PNG}
|
|
\caption{Analyse temporelle.}
|
|
\label{fig:decodeur5}
|
|
\end{figure}
|
|
|
|
\section{Programmation}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\begin{minipage}{0.45\textwidth}
|
|
\centering
|
|
\includegraphics[width=\textwidth]{images/decodeur6.jpg}
|
|
\caption{Affichage du chiffre 9}
|
|
\label{fig:decodeur6}
|
|
\end{minipage}
|
|
\begin{minipage}{0.45\textwidth}
|
|
\centering
|
|
\includegraphics[width=\textwidth]{images/decodeur7.jpg}
|
|
\caption{Affichage du chiffre 5}
|
|
\label{fig:decodeur7}
|
|
\end{minipage}
|
|
\end{figure}
|
|
|
|
|
|
On programme la carte et on vérifie le fonctionnement en changeant l'état des interrupteurs, comme le montre les figures \ref{fig:decodeur6} et \ref{fig:decodeur7}.
|
|
|
|
\FloatBarrier
|
|
\clearpage
|
|
\part{Traitement d'un bouton poussoir}
|
|
|
|
Afin de détecter l'appui sur un bouton poussoir, on réalise un traitement de l'entrée associée. En effet il faut d'abord éliminer un éventuel bruit créé par les rebonds créés lors du changement de l'état du bouton et synchroniser le signal avec celui de l'horloge afin d'obtenir le signal \verb|BPS|. Cette partie est réalisée avec une bascule D (on suppose donc que le bruit dure moins d'une période d'horloge). On souhaite ensuite passer la sortie à l'état haut pendant une période d'horloge sur front montant de \verb|BPS|. On se propose de synthétiser cette partie avec une machine de \bsc{Moore} puis avec une machine de \bsc{Mealy}.
|
|
|
|
\paragraph{Note :} On remarquera que du fait du câblage des boutons (figure \ref{fig:elecbouton}), un appui sur un bouton se traduira par le passage à l'état bas de l'entrée correspondante. Par soucis de simplicité, les calculs de cette partie se font en supposant le fonctionnement inversé. Ce n'est pas un problème puisqu'il suffit d'ajouter une porte inverseuse entre le bouton et l'entrée de notre système pour corriger cela. Les schémas présentés en fin de section auront donc une porte inverseuse en entrée.
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.5\linewidth]{images/elec_bouton}
|
|
\caption{Câblage d'un bouton poussoir}
|
|
\label{fig:elecbouton}
|
|
\end{figure}
|
|
|
|
|
|
\section{Synthèse avec une machine de \bsc{Moore}}
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\begin{wave}{3}{5}
|
|
\nextwave{BPS} \bit{0}{1} \bit{1}{3} \bit{0}{2}
|
|
\nextwave{SBPMoore} \bit{0}{2} \bit{1}{1} \bit{0}{3}
|
|
\end{wave}
|
|
\caption{Chronogramme recherché}
|
|
\label{fig:chronoMooreTheo}
|
|
\end{figure}
|
|
|
|
On commence par résumer à l'aide d'un chronogramme le comportement recherché pour le système, représenté à la figure \ref{fig:chronoMooreTheo}.
|
|
|
|
On souhaite réaliser une machine de \bsc{Moore}, c'est à dire $S = g(E_p)$ et $ E_S = f(E,E_p)$, avec $S$, $E_p$ et $E$ tels que représentés à la figure \ref{fig:diagrammeMoore}.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\begin{minipage}{0.45\linewidth}
|
|
\centering
|
|
\begin{tikzpicture}
|
|
\draw (0,0) -- (1,0) -- (1,-0.5) -- (1,-0.25) node[anchor=east] {g} --(1,-0.5) -- (0,-2) -- (0,0) --
|
|
(1,-1.5) -- (1,-1.75) node[anchor=east]{f} -- (1,-2) -- (0,-2);
|
|
|
|
\draw (0,-2.25) -- (1,-2.25) -- (1,-2.5) node[anchor=east]{D} -- (1,-3.25) -- (0.5, -3.25) node[anchor=south]{H} -- (0,-3.25) -- (0,-2.5) node[anchor=west]{Q} -- (0,-2.25);
|
|
|
|
\draw[->] (-0.5,-0.25) node[anchor=east] {BPS} -- (0,-0.25);
|
|
\draw[->] (1,-0.25) -- (1.5, -0.25) node[anchor=west] {SBPMoore};
|
|
|
|
\draw[->] (1,-1.75) -- (1.25,-1.75) node[anchor = west] {$E_S$}-- (1.25, -2.5) -- (1, -2.5);
|
|
\draw[->] (0,-2.5) -- (-0.25,-2.5) -- (-0.25, -1.75) node[anchor = east] {$E_p$}-- (0,-1.75);
|
|
\draw[->] (0.5,-3.5) -- (0.5,-3.25);
|
|
|
|
\end{tikzpicture}
|
|
\caption{Schéma général d'un système séquentiel synchrone}
|
|
\label{fig:diagrammeMoore}
|
|
\end{minipage}
|
|
\begin{minipage}{0.45\linewidth}
|
|
|
|
\centering
|
|
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2cm,
|
|
semithick]
|
|
|
|
\node[state] (A) {$E_0$};
|
|
\node [state](B)[right of=A]{$E_1$};
|
|
\node[state](C)[below of=A]{$E_2$};
|
|
|
|
\path (A) edge[loop left] node {0} (A)
|
|
(A) edge[bend left] node {1} (B)
|
|
(B) edge[bend left] node {1} (C)
|
|
(C) edge[loop left] node{1} (C)
|
|
(C) edge[bend left] node{0} (A)
|
|
(B) edge[bend left] node{0} (A)
|
|
;
|
|
\end{tikzpicture}
|
|
\caption{Automate des états de la machine de \bsc{Moore}}
|
|
\label{fig:automateMoore}
|
|
\end{minipage}
|
|
\end{figure}
|
|
|
|
On synthétise ensuite le fonctionnement de la machine en dessinant le graphe des états, représenté à la figure \ref{fig:automateMoore}. On obtient un graphe à trois états. Un premier état de repos, et deux autres permettants de passer la sortie au niveau 1 pendant un cycle d'horloge sur front montant de l'entrée.
|
|
|
|
On peut alors écrire le tableau des états (table \ref{tab:tableauEtatMoore}), en utilisant le codage des états reproduit dans la table \ref{tab:tableaucodeEtatMoore} (on pose $E_p = (y_1,y_0)$).
|
|
|
|
\begin{table}[h!]
|
|
\centering
|
|
\begin{minipage}{0.45\textwidth}
|
|
\centering
|
|
\begin{tabular}{| r | c c |}
|
|
\hline
|
|
& $y_1$ & $y_0$ \\
|
|
\hline
|
|
$E_0$ & 0 & 0 \\
|
|
$E_1$ & 0 & 1 \\
|
|
$E_2$ & 1 & 0 \\
|
|
\hline
|
|
\end{tabular}
|
|
\caption{Codage des états de la machine de \bsc{Moore}}
|
|
\label{tab:tableaucodeEtatMoore}
|
|
\end{minipage}
|
|
\begin{minipage}{0.45\textwidth}
|
|
\centering
|
|
\begin{tabular}{| c | c | c || l |}
|
|
\hline
|
|
\backslashbox{$E_p$}{$BPS$} & 0 & 1 & S \\
|
|
\hline
|
|
$E_0$ & $E_0$ & $E_1$ & 0 \\
|
|
$0\;0$ & $0\;0$ & $0\;1$ & \\
|
|
\hline
|
|
$E_1$ & $E_0$ & $E_2$ & 1 \\
|
|
$0\;1$ & $0\;0$ & $1\;0$ & \\
|
|
\hline
|
|
$E_2$ & $E_0$ & $E_2$ & 0 \\
|
|
$1\;0$ & $0\;0$ & $1\;0$ & \\
|
|
\hline
|
|
\end{tabular}
|
|
\caption{Tableau des états de la machine de \bsc{Moore}}
|
|
\label{tab:tableauEtatMoore}
|
|
\end{minipage}
|
|
\end{table}
|
|
|
|
On peut ensuite synthétiser l'état suivant $E_S$ et la sortie $S$ en fonction de $BPS$, $y_0$ et $y_1$. On réalise pour cela trois tableaux de \bsc{Karnaugh} (tables \ref{tab:KY0Moore}, \ref{tab:KY1Moore} et \ref{tab:KSMoore}).
|
|
|
|
\begin{table}[h!]
|
|
\centering
|
|
\begin{minipage}{0.45\textwidth}
|
|
\centering
|
|
\begin{tabular}{| c | c c c c |}
|
|
\hline
|
|
\backslashbox{$BPS$}{$y_1 y_0$} & 00 & 01 & 11 & 10 \\
|
|
\hline
|
|
0 & 0 & 0 & - & 0 \\
|
|
1 & 1 & 0 & - & 0 \\
|
|
\hline
|
|
\end{tabular}
|
|
\caption{Tableau de \bsc{Karnaugh} pour la variable $Y_0$}
|
|
\label{tab:KY0Moore}
|
|
\end{minipage}
|
|
\begin{minipage}{0.45\textwidth}
|
|
\centering
|
|
\begin{tabular}{| c | c c c c |}
|
|
\hline
|
|
\backslashbox{$BPS$}{$y_1 y_0$} & 00 & 01 & 11 & 10 \\
|
|
\hline
|
|
0 & 0 & 0 & - & 0 \\
|
|
1 & 0 & 1 & - & 1 \\
|
|
\hline
|
|
\end{tabular}
|
|
\caption{Tableau de \bsc{Karnaugh} pour la variable $Y_1$}
|
|
\label{tab:KY1Moore}
|
|
\end{minipage}
|
|
\begin{minipage}{0.45\textwidth}
|
|
\centering
|
|
\begin{tabular}{| c | c c c c |}
|
|
\hline
|
|
\backslashbox{$BPS$}{$y_1 y_0$} & 00 & 01 & 11 & 10 \\
|
|
\hline
|
|
0 & 0 & 1 & - & 0 \\
|
|
1 & 0 & 1 & - & 0 \\
|
|
\hline
|
|
\end{tabular}
|
|
\caption{Tableau de \bsc{Karnaugh} pour la variable $S$}
|
|
\label{tab:KSMoore}
|
|
\end{minipage}
|
|
\end{table}
|
|
|
|
On peut alors obtenir l'équation de chaque variables.
|
|
\begin{eqnarray}
|
|
Y_0 &=& BPS \cdot \bar{y_0} \cdot \bar{y_1} \\
|
|
Y_1 &=& BPS \cdot (y_0 + y_1) \\
|
|
S &=& y_0
|
|
\end{eqnarray}
|
|
|
|
Enfin, on vérifie que le fonctionnement est celui attendu par simulation, ce que montrent les figures \ref{fig:schemaBpMoore} (présenté avec la porte inverseuse en entrée pour tenir compte du câblage du bouton) et \ref{fig:chronoBpMoore}.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.7\linewidth]{images/bp1_bis.PNG}
|
|
\caption{Schéma du montage}
|
|
\label{fig:schemaBpMoore}
|
|
\end{figure}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.7\linewidth]{images/bp2.PNG}
|
|
\caption{Chronogramme de la simulation}
|
|
\label{fig:chronoBpMoore}
|
|
\end{figure}
|
|
|
|
\section{Synthèse avec une machine de \bsc{Mealy}}
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\begin{wave}{3}{5}
|
|
\nextwave{BPS} \bit{0}{1} \bit{1}{3} \bit{0}{2}
|
|
\nextwave{SBPMealy} \bit{0}{1} \bit{1}{1} \bit{0}{4}
|
|
\end{wave}
|
|
\caption{Chronogramme recherché}
|
|
\label{fig:chronoMealyTheo}
|
|
\end{figure}
|
|
|
|
On commence par résumer à l'aide d'un chronogramme le comportement recherché pour le système, représenté à la figure \ref{fig:chronoMealyTheo}.
|
|
|
|
On souhaite réaliser une machine de \bsc{Mealy}, c'est à dire $S = g(E, E_p)$ et $ E_S = f(E,E_p)$, avec $S$, $E_p$ et $E$ tels que représentés à la figure \ref{fig:diagrammeMealy}.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\begin{minipage}{0.45\linewidth}
|
|
\centering
|
|
\begin{tikzpicture}
|
|
\draw (0,0) -- (1,0) -- (1,-0.5) -- (1,-0.25) node[anchor=east] {g} --(1,-0.5) -- (0,-2) -- (0,0) --
|
|
(1,-1.5) -- (1,-1.75) node[anchor=east]{f} -- (1,-2) -- (0,-2);
|
|
|
|
\draw (0,-2.25) -- (1,-2.25) -- (1,-2.5) node[anchor=east]{D} -- (1,-3.25) -- (0.5, -3.25) node[anchor=south]{H} -- (0,-3.25) -- (0,-2.5) node[anchor=west]{Q} -- (0,-2.25);
|
|
|
|
\draw[->] (-0.5,-0.25) node[anchor=east] {BPS} -- (0,-0.25);
|
|
\draw[->] (1,-0.25) -- (1.5, -0.25) node[anchor=west] {SBPMealy};
|
|
|
|
\draw[->] (1,-1.75) -- (1.25,-1.75) node[anchor = west] {$E_S$}-- (1.25, -2.5) -- (1, -2.5);
|
|
\draw[->] (0,-2.5) -- (-0.25,-2.5) -- (-0.25, -1.75) node[anchor = east] {$E_p$}-- (0,-1.75);
|
|
\draw[->] (0.5,-3.5) -- (0.5,-3.25);
|
|
|
|
\end{tikzpicture}
|
|
\caption{Schéma général d'un système séquentiel synchrone}
|
|
\label{fig:diagrammeMealy}
|
|
\end{minipage}
|
|
\begin{minipage}{0.45\linewidth}
|
|
|
|
\centering \begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2cm,
|
|
semithick]
|
|
|
|
\node[state] (A) {$E_0$};
|
|
\node [state](B)[right of=A]{$E_1$};
|
|
|
|
\path node[above left=0.25cm]{$S=BPS$}(A) edge[loop left] node {0} (A)
|
|
(A) edge[bend left] node {1} (B)
|
|
(B) edge[bend left] node{0} (A)
|
|
node[above right=0.25cm]{$S=0$}(B) edge[loop right] node {1} (B)
|
|
;
|
|
\end{tikzpicture}
|
|
\caption{Automate des états de la machine de \bsc{Moore}}
|
|
\label{fig:automateMealy}
|
|
\end{minipage}
|
|
\end{figure}
|
|
|
|
On synthétise ensuite le fonctionnement de la machine en dessinant le graphe des états, représenté à la figure \ref{fig:automateMealy}. On obtient un graphe à deux états. Un premier état de repos qui permet de passer la sortie à l'état un dès que le bouton poussoir est enfoncé, et un autre permettant empêchant la sortie de rester au niveau haut plus d'un cycle d'horloge lors de l'appui.
|
|
|
|
On peut ensuite synthétiser l'état suivant $E_S$ et la sortie $S$ en fonction de $BPS$ et $E_p$. On réalise pour cela deux tableaux de \bsc{Karnaugh} (tables \ref{tab:KESMealy}, \ref{tab:KSMealy}).
|
|
|
|
\begin{table}[h!]
|
|
\centering
|
|
\begin{minipage}{0.45\textwidth}
|
|
\centering
|
|
\begin{tabular}{| c | c c |}
|
|
\hline
|
|
\backslashbox{$BPS$}{$E_p$} & 0 & 1 \\
|
|
\hline
|
|
0 & 0 & 1 \\
|
|
1 & 0 & 1 \\
|
|
\hline
|
|
\end{tabular}
|
|
\caption{Tableau de \bsc{Karnaugh} pour la variable $E_S$}
|
|
\label{tab:KESMealy}
|
|
\end{minipage}
|
|
\begin{minipage}{0.45\textwidth}
|
|
\centering
|
|
\begin{tabular}{| c | c c |}
|
|
\hline
|
|
\backslashbox{$BPS$}{$E_p$} & 0 & 1 \\
|
|
\hline
|
|
0 & 0 & 1 \\
|
|
1 & 0 & 0 \\
|
|
\hline
|
|
\end{tabular}
|
|
\caption{Tableau de \bsc{Karnaugh} pour la sortie}
|
|
\label{tab:KSMealy}
|
|
\end{minipage}
|
|
\end{table}
|
|
|
|
On peut alors obtenir l'équation de chaque variables.
|
|
\begin{eqnarray}
|
|
E_S &=& BPS \\
|
|
S &=& BPS \cdot \bar{E_p}
|
|
\end{eqnarray}
|
|
|
|
Enfin, on vérifie que le fonctionnement est celui attendu par simulation, ce que montrent les figures \ref{fig:schemaBpMealy} (présenté avec la porte inverseuse en entrée pour tenir compte du câblage du bouton) et \ref{fig:chronoBpMealy}.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.7\linewidth]{images/bp3_bis.PNG}
|
|
\caption{Schéma du montage}
|
|
\label{fig:schemaBpMealy}
|
|
\end{figure}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.7\linewidth]{images/bp4.PNG}
|
|
\caption{Chronogramme de la simulation}
|
|
\label{fig:chronoBpMealy}
|
|
\end{figure}
|
|
|
|
\clearpage
|
|
\part{Diviseur de fréquence}
|
|
|
|
Le quartz de la carte délivre un signal d'horloge à 27.175MHz. On souhaite baisser cette fréquence à 100Hz afin de faciliter le comptage pour le chronomètre et d'offrire une expérience proche du temps réel à l'utilisateur.
|
|
|
|
\section{Structure du diviseur}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.7\linewidth]{images/div1.png}
|
|
\caption{Schéma du diviseur de fréquence.}
|
|
\label{fig:schemaDiv}
|
|
\end{figure}
|
|
|
|
\section{Détermination du premier rapport de division}
|
|
|
|
On cherche dans un premier temps à déterminer le rapport de division de fréquence que doit offrir le premier diviseur. On synthétise la première division de fréquence par la figure \ref{fig:divReduc1}, avec $\alpha$ le rapport de division du premier diviseur.
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\begin{tikzpicture}
|
|
|
|
\draw[->] (0,0) node[anchor=east ]{$25\;175\;000\;Hz$} -- (0.5,0) node[anchor=south]{$\frac{1}{\alpha}$} -- (1,0) node[anchor=west]{$f_1$}[anchor=east];
|
|
\draw[->] (1.5,0) -- (2,0) node[anchor=south]{$\frac{1}{\beta}$} -- (2.5,0) node[anchor=west]{$200\;Hz$};
|
|
|
|
\end{tikzpicture}
|
|
\caption{Synthèse de la réduction de fréquence.}
|
|
\label{fig:divReduc1}
|
|
\end{figure}
|
|
|
|
On souhaite de plus que $\beta$ soit entier. Puisqu'il n'y a qu'un nombre réduit de possibilités pour le premier diviseur, on va chercher parmis les différentes valeurs possibles de $\alpha$ celle qui donne $\beta$ entier. On a la relation $\alpha \times \beta = \frac{251\;750}{2}$. À l'aide d'un tableur (figure \ref{fig:rapportDiv}), on détermine $\alpha = 5$ et $\beta = 25\;175$.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=\textwidth]{images/div2.png}
|
|
\caption{Utilisation d'un tableur pour déterminer $\alpha$}
|
|
\label{fig:rapportDiv}
|
|
\end{figure}
|
|
|
|
\section{Compteur}
|
|
|
|
On va ensuite réaliser la division de fréquence d'un facteur $\beta$ à l'aide d'un compteur 16 bits (réalisé par mise en cascade de deux compteurs 8 bits \verb|8count|). On détermine la valeur $x$ jusqu'à laquelle le compteur 16 bits doit compter :
|
|
\[
|
|
x = \underbrace{256\times256}_{=65\;536 =\mathrm{val.\;max\;de\;comptage}} - \beta
|
|
\]
|
|
|
|
On va donc compter jusqu'à $40\;361_{(10)} = 1001\;1101\;1010\;1001_{(2)}$.
|
|
|
|
\section{Diviseur par 2}
|
|
|
|
Afin d'avoir un rapport cyclique de $\frac{1}{2}$ on utilise un diviseur par deux en sortie. Le fonctionnement recherché est résumé par le chronogramme de la figure \ref{fig:chronoDiv2}.
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\begin{nowave}{10}
|
|
\nextwave{Signal à $200\;Hz$} \bit{0}{1} \bit{1}{1} \bit{0}{3} \bit{1}{1} \bit{0}{3} \bit{1}{1}
|
|
\nextwave{Sortie ($100\;Hz$)} \bit{0}{2} \bit{1}{4} \bit{0}{4}
|
|
\end{nowave}
|
|
\caption{Chronogramme du comportement recherché}
|
|
\label{fig:chronoDiv2}
|
|
\end{figure}
|
|
|
|
On synthétise alors le graphe des états correspondant (figure \ref{fig:automateDiv2}).
|
|
|
|
\begin{figure}[h!]
|
|
\centering \begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2cm,
|
|
semithick]
|
|
|
|
\node[state] (A) {$E_0$};
|
|
\node [state](B)[right of=A]{$E_1$};
|
|
|
|
\path node[above left=0.25cm]{$S=0$}(A) edge[loop left] node {0} (A)
|
|
(A) edge[bend left] node {1} (B)
|
|
(B) edge[bend left] node{1} (A)
|
|
node[above right=0.25cm]{$S=1$}(B) edge[loop right] node {0} (B)
|
|
;
|
|
\end{tikzpicture}
|
|
\caption{Automate des états de la machine de \bsc{Moore}}
|
|
\label{fig:automateDiv2}
|
|
\end{figure}
|
|
|
|
On réalise le tableau des états (table \ref{tab:tableauEtatDiv2}) et on en déduit l'équation de la sortie en fonction de l'entrée $E$.
|
|
|
|
\begin{table}[h!]
|
|
\centering
|
|
\begin{tabular}{| c | c | c || l |}
|
|
\hline
|
|
\backslashbox{$E_p$}{Entrée} & 0 & 1 & S \\
|
|
\hline
|
|
0 & 0 & 1 & 0 \\
|
|
\hline
|
|
1 & 1 & 0 & 1 \\
|
|
\hline
|
|
\end{tabular}
|
|
\caption{Tableau des états du diviseur par 2}
|
|
\label{tab:tableauEtatDiv2}
|
|
\end{table}
|
|
|
|
On a ainsi :
|
|
\[
|
|
S = \bar{E_p}\cdot E + E_p\cdot\bar{E}
|
|
\]
|
|
On reconnaît l'équation d'une bascule T. On utilisera donc cette bascule pour réaliser le diviseur par deux.
|
|
|
|
\section{Réalisation du diviseur}
|
|
|
|
On modélise d'abord le schéma dans Quartus (figure \ref{fig:divSchema}).
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.7\linewidth]{images/div3}
|
|
\caption{Schéma réalisé dans Quartus}
|
|
\label{fig:divSchema}
|
|
\end{figure}
|
|
|
|
Puis on vérifie à l'oscilloscope que l'on obtient bien un signal à $100\;Hz$ en sortie (figure \ref{fig:divOscillo}).
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=\linewidth]{images/div4.jpg}
|
|
\caption{Mesure à l'oscilloscope}
|
|
\label{fig:divOscillo}
|
|
\end{figure}
|
|
|
|
\clearpage
|
|
\part{Partie opérative et séquenceur}
|
|
|
|
Cette partie vise à synthétiser la partie opérative et le séquenceur. La figure \ref{fig:opSeq} montre l'interfaçage de ces deux parties.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.7\linewidth]{images/op1}
|
|
\caption{Séquenceur et chemin de données}
|
|
\label{fig:opSeq}
|
|
\end{figure}
|
|
|
|
\section{Chemin de données}
|
|
On souhaite réaliser le chemin de données du chronomètre. Cette partie devra décompter le temps à partir du signal à 1OOHz de l'horloge, et l'afficher sur les afficheurs 7 segments de la carte. De plus elle acceptera deux entrées : une pour réinitialiser le chronomètre et une autre pour autoriser ou stopper le décompte du temps.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=\linewidth]{images/op2}
|
|
\caption{Schéma réalisé dans Quartus}
|
|
\label{fig:opSchema}
|
|
\end{figure}
|
|
|
|
Pour réaliser le décompte du temps, on utilise une association de compteurs similaire à celle du diviseur de fréquence. Le composant utilisé est le \verb|74168|. On utilise 3 compteurs afin d'obtenir le décompte des centièmes de secondes (non affiché), des dixièmes de secondes et des secondes. On utilise des décodeurs \verb|7446| pour piloter les afficheurs 7 segments. Le décompte est autorisé par le passage à l'état bas de l'entrée \verb|COUNT| du chemin de données (reliée à \verb|ENTN| et \verb|ENPN| du premier compteur 74168). On peut réinitialiser la valeur du chronomètre en passant l'entrée \verb|RESET| à l'état bas (reliée au chargement parallèle des compteurs). On obtient le schéma de la figure \ref{fig:opSchema}.
|
|
|
|
Afin de tester cette partie du montage, on introduit dans le bloc l'horloge à 100Hz réalisée précédemment et on fixe les valeurs de \verb|COUNT| et \verb|RESET|. Après téléchargement sur la carte, on vérifie que l'on obtient bien un décompte des secondes et des dixièmes de secondes (figure \ref{fig:opReal}).
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=\linewidth]{images/op3}
|
|
\caption{Test du chemin de données}
|
|
\label{fig:opReal}
|
|
\end{figure}
|
|
|
|
\section{Séquenceur}
|
|
|
|
On souhaite maintenant réaliser le séquenceur. Il prendra deux entrées : \verb|SPB1| et \verb|SBP2|, et deux sorties : \verb|COUNT| et \verb|RESET| qui viendrons s'interfacer avec le chemin de données. On cherche le comportement suivant:
|
|
\begin{itemize}
|
|
\item Si l'on appuie sur \verb|BP1| le signal \verb|RESET| est actif (passage à zéro);
|
|
\item Le bouton \verb|BP2| permet de naviguer entre les modes comptage et décomptage (passage de \verb|COUNT| à 1 ou 0).
|
|
\end{itemize}
|
|
|
|
On synthétise ce comportement en une machine de \bsc{Mealy} comme le montre le graphe des états en figure \ref{fig:automateSeq}.
|
|
|
|
\begin{figure}[h!]
|
|
\centering \begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node distance=2cm,
|
|
semithick]
|
|
|
|
\node[state] (A) {$E_0$};
|
|
\node [state](B)[right of=A]{$E_1$};
|
|
|
|
\path
|
|
(A) edge[loop left] node {$\overline{BP2} + BP1$} (A)
|
|
(A) edge[bend left] node {$BP2 \cdot \overline{BP1}$} (B)
|
|
(B) edge[bend left] node{$BP1 + BP2$} (A)
|
|
(B) edge[loop right] node {$\overline{BP2} \cdot \overline{BP1}$} (B)
|
|
;
|
|
\end{tikzpicture}
|
|
\caption{Automate des états de la machine de \bsc{Moore}}
|
|
\label{fig:automateSeq}
|
|
\end{figure}
|
|
|
|
L'état $E_0$ correspond à un état d'attente et $E_1$ de comptage.
|
|
|
|
Puis on synthétise les transitions dans le tableau binaire des états représenté en table \ref{tab:KSeq} (puisqu'il n'y a que deux états, on se permettra de confondre $E_P$ avec son codage sur un bit). On synthétise également l'état des sorties (tables \ref{tab:KSeqCount} et \ref{tab:KSeqReset}).
|
|
|
|
\begin{table}
|
|
\centering
|
|
\begin{tabular}{| c | c c c c |}
|
|
\hline
|
|
\backslashbox{$E_p$}{$BP1 \; BP2$} & 00 & 01 & 11 & 10 \\
|
|
\hline
|
|
0 & 0 & 1 & 0 & 0 \\
|
|
1 & 1 & 0 & 0 & 0 \\
|
|
\hline
|
|
\end{tabular}
|
|
\caption{Tableau de \bsc{Karnaugh} pour l'état suivant}
|
|
\label{tab:KSeq}
|
|
\end{table}
|
|
|
|
\begin{table}
|
|
\centering
|
|
\begin{minipage}{0.45\linewidth}
|
|
\centering
|
|
\begin{tabular}{| c | c c c c |}
|
|
\hline
|
|
\backslashbox{$E_p$}{$BP1 \; BP2$} & 00 & 01 & 11 & 10 \\
|
|
\hline
|
|
0 & 1 & 1 & 1 & 1 \\
|
|
1 & 0 & 0 & 0 & 0 \\
|
|
\hline
|
|
\end{tabular}
|
|
\caption{Tableau de \bsc{Karnaugh} pour $COUNT$}
|
|
\label{tab:KSeqCount}
|
|
\end{minipage}
|
|
\begin{minipage}{0.45\linewidth}
|
|
\centering
|
|
\begin{tabular}{| c | c c c c |}
|
|
\hline
|
|
\backslashbox{$E_p$}{$BP1 \; BP2$} & 00 & 01 & 11 & 10 \\
|
|
\hline
|
|
0 & 1 & 1 & 0 & 0 \\
|
|
1 & 1 & 1 & 0 & 0 \\
|
|
\hline
|
|
\end{tabular}
|
|
\caption{Tableau de \bsc{Karnaugh} pour $RESET$}
|
|
\label{tab:KSeqReset}
|
|
\end{minipage}
|
|
\end{table}
|
|
|
|
On peut alors en déduire les équations de l'état suivant et des sorties.
|
|
|
|
\begin{eqnarray}
|
|
COUNT &=& \overline{E_P} \\
|
|
RESET &=& \overline{BP1} \\
|
|
E_S &=& \overline{BP1} \cdot (BP2 \oplus E_P) \\
|
|
\end{eqnarray}
|
|
|
|
Enfin on réalise le montage sur Quartus (figure \ref{fig:sequenceur}) et on le simule (figure \ref{fig:seq2}).
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.7\linewidth]{images/sequenceur}
|
|
\caption{Schéma du séquenceur}
|
|
\label{fig:sequenceur}
|
|
\end{figure}
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.7\linewidth]{images/seq2}
|
|
\caption{Simulation fonctionnelle du séquenceur}
|
|
\label{fig:seq2}
|
|
\end{figure}
|
|
\clearpage
|
|
\part{Réalisation du chronomètre}
|
|
En assemblant les éléments synthétisés dans les parties précédentes selon ce qui est proposé dans le sujet (figure \ref{fig:structure}), on obtient le schéma de la figure \ref{fig:chrono}.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=1\linewidth]{images/structure}
|
|
\caption{Structure du chronomètre}
|
|
\label{fig:structure}
|
|
\end{figure}
|
|
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=\linewidth]{images/chrono}
|
|
\caption{Schéma du chronomètre}
|
|
\label{fig:chrono}
|
|
\end{figure}
|
|
|
|
\part{Conclusion}
|
|
En téléversant le schéma sur la carte on vérifié que l'on obtient bien le comportement recherché :
|
|
\begin{itemize}
|
|
\item Un appui sur \verb|START/STOP| arrête ou démarre le chronomètre;
|
|
\item Un appui sur \verb|RESET| arrête le chronomètre et le remet à zéro;
|
|
\item Le chronomètre compte 10 secondes et se réinitialise, en affichant les secondes et les dixièmes de seconde;
|
|
\item Le point le point lumineux entre les secondes et les dixièmes de secondes et affiché.
|
|
\end{itemize}
|
|
On a donc répondu au cahier des charges, ce qui conclue cette étude.
|
|
|
|
\clearpage
|
|
\listoffigures
|
|
\end{document}
|