C'est bientôt la merde
authorPaul Kocialkowski <contact@paulk.fr>
Mon, 4 May 2015 19:11:00 +0000 (21:11 +0200)
committerPaul Kocialkowski <contact@paulk.fr>
Mon, 4 May 2015 19:11:00 +0000 (21:11 +0200)
19 files changed:
annexes.tex
applications-logiques.tex
aspects-informatique.tex
avant-propos.tex
biblio.bib
images/ardui2c.jpg [new file with mode: 0644]
images/chronogramme-multivibrateur.png [new file with mode: 0644]
images/compteur-experimental.jpg [new file with mode: 0644]
images/compteur-final.jpg [new file with mode: 0644]
images/encodage-1.png [new file with mode: 0644]
images/encodage-2.png [new file with mode: 0644]
images/encodage-8.png [new file with mode: 0644]
images/multivibrateur.jpg [new file with mode: 0644]
images/schmitt.jpg [deleted file]
images/systeme-alarme-photo.png [new file with mode: 0644]
images/systeme-led-photo.png [new file with mode: 0644]
main.tex
phenomenes-circuits-temps.tex
resume.tex

index 6c398b6..86aef99 100644 (file)
@@ -1,14 +1,26 @@
 \appendix
 \chapter{}
 
-\begin{figure}[h]
+\begin{figure}[!h]
+\includegraphics[width=\linewidth]{multivibrateur.jpg}
+\caption{Multivibrateur astable monté sur une platine d'expérimentation}
+\label{mv_photo}
+\end{figure}\\
+
+\begin{figure}[!h]
 \centering
 \includegraphics[width=\linewidth]{incrementation.png}
 \caption{Montage de décompte sur 2 bits}
 \label{incrementation}
 \end{figure}
 
-\begin{figure}[h]
+\begin{figure}[!h]
+\includegraphics[width=\linewidth]{compteur-experimental.jpg}
+\caption{Montage de décompte monté sur une platine d'expérimentation}
+\label{compteur-experimental}
+\end{figure}
+
+\begin{figure}[!h]
 \centering
 \includegraphics[width=\linewidth]{incrementation-simplifie.png}
 \caption{Montage de décompte sur 2 bits après simplifications}
 \label{incrementation-final-nand}
 \end{figure}
 
+\begin{figure}[!h]
+\includegraphics[width=\linewidth]{compteur-final.jpg}
+\caption{Montage de décompte final monté sur une platine d'expérimentation}
+\label{compteur-final}
+\end{figure}
+
 \begin{figure}[h]
 \centering
 \includegraphics[width=5cm]{systeme-led.png}
-\caption{Système d'affichage du décompte des secondes en représentation binaire}
+\caption{Schéma du système d'affichage du décompte des secondes en représentation binaire}
 \label{systeme-led}
 \end{figure}
 
+\begin{figure}[!h]
+\includegraphics[width=\linewidth]{systeme-led-photo.png}
+\caption{Système de décompte des secondes en représentation binaire sur une platine d'expérimentation, connecté aux autres modules}
+\label{systeme-led-photo}
+\end{figure}
+
 \begin{figure}[h]
 \centering
 \includegraphics[width=\linewidth]{systeme-alarme.png}
-\caption{Système d'alarme sonore pour la cuisson d'un œuf à la coque avec rappel clignotant de période $30$ secondes}
+\caption{Système d'alarme sonore pour la cuisson d'un œuf à la coque}
 \label{systeme-alarme}
 \end{figure}
 
+\begin{figure}[!h]
+\includegraphics[width=\linewidth]{systeme-alarme-photo.png}
+\caption{Système d'alarme sonore pour la cuisson d'un œuf à la coque sur une platine d'expérimentation, connecté aux autres modules}
+\label{systeme-alarme-photo}
+\end{figure}
+
 \chapter{}
 
+\begin{figure}[!h]
+\includegraphics[width=\linewidth]{ardui2c.jpg}
+\caption{La Cubieboar2 et l'Arduino connectés par le bus \iic, avec l'analyseur logique}
+\label{ardui2c-photo}
+\end{figure}
+
 \lstinputlisting[caption=Ardui2c,label=ardui2c]{ardui2c.c}
+
+\begin{figure}[!h]
+\centering
+\begin{subfigure}[b]{10cm}
+\centering
+\includegraphics[width=\textwidth]{encodage-1.png}
+\caption{Avec 1 cœur}
+\end{subfigure}
+\hfill
+\begin{subfigure}[b]{10cm}
+\centering
+\includegraphics[width=\textwidth]{encodage-2.png}
+\caption{Avec 2 cœurs}
+\end{subfigure}
+\hfill
+\begin{subfigure}[b]{10cm}
+\centering
+\includegraphics[width=\textwidth]{encodage-8.png}
+\caption{Avec 8 cœurs}
+\end{subfigure}
+\caption{Graphiques d'utilisation des cœurs du processeur lors de l'encodage}
+\label{encodage}
+\end{figure}
+
+\lstinputlisting[caption=Programme d'exemple de calcul parallèle,label=thread]{thread.c}
+
+\lstinputlisting[caption=Différences introduites pour tenir compte de la synchronisation,label=thread-diff]{thread.diff}
index f23d59d..cf02817 100644 (file)
@@ -234,7 +234,7 @@ On propose une solution de synchronisation en deux temps, où la valeur d'entré
 \caption{Solution de synchronisation proposée}
 \end{figure}
 
-On utilise deux bascules RS asynchrones, simples à réaliser et au fonctionnement bien connu. On synchronise alors la première bascule sur le temps haut de l'horloge avec deux portes ET reliées à $H$ sur les entrées $R$ et $S$, on relie l'entrée du montage à la porte ET reliée à l'entrée $S$ de la bascule et on relie l'inverse de l'entrée du montage pour la porte ET reliée à l'entrée $R$ de la bascule. De fait, l'état de l'entrée est recopié en sortie de la bascule pendant l'état haut de l'horloge et reste inchangé pendant le temps bas. On y associe alors une seconde bascule synchronisée de la même façon mais sur l'état bas de l'horloge (avec deux portes ET reliées à $\overline{H}$) et on relie la sortie $Q$ (resp. $\overline{Q}$ de la première bascule à l'entrée $S$ (resp. $R$) (au travers des portes ET). De fait, pendant le temps bas de l'horloge, l'état intermédiaire de sortie de la première bascule (qui est inchangé) est recopié en sortie par la seconde bascule, qui restera alors inchangée pendant le temps haut, ce-qui fournit le résultat attendu.\\
+On utilise deux bascules RS asynchrones, simples à réaliser et au fonctionnement bien connu. On synchronise alors la première bascule sur le temps haut de l'horloge avec deux portes ET reliées à $H$ sur les entrées $R$ et $S$, on relie l'entrée du montage à la porte ET reliée à l'entrée $S$ de la bascule et on relie l'inverse de l'entrée du montage pour la porte ET reliée à l'entrée $R$ de la bascule. De fait, l'état de l'entrée est recopié en sortie de la bascule pendant l'état haut de l'horloge et reste inchangé pendant le temps bas. On y associe alors une seconde bascule synchronisée de la même façon mais sur l'état bas de l'horloge (avec deux portes ET reliées à $\overline{H}$) et on relie la sortie $Q$ (resp. $\overline{Q}$ de la première bascule à l'entrée $S$ (resp. $R$) (au travers des portes ET). De fait, pendant le temps bas de l'horloge, l'état intermédiaire de sortie de la première bascule (qui est inchangé) est recopié en sortie par la seconde bascule, qui restera alors inchangée pendant le temps haut, ce-qui fournit le résultat attendu. Il s'agit d'une technique d'utilisation des bascules avec sensitivité aux états logiques de l'horloge\citenote{CoursLogique}.\\
 
 On considérera ici que les temps de propagation des signaux sont négligeables, de sorte que les états $H$ et $\overline{H}$ sont identiques ne tout points du circuit. Si ce n'est pas exactement rigoureux, le temps que les bascules changent d'état, toujours supérieurs aux temps de propagation des signaux\citenotepage{Tocci}{187} pourront jouer en notre faveur et éviter que, même dans le cas où on a effectivement  $H = \overline{H}$, le circuit recopie directement l'entrée à la sortie.
 
@@ -243,7 +243,7 @@ On considérera ici que les temps de propagation des signaux sont négligeables,
 On conçoit alors un premier montage qui utilise directement cette solution de synchronisation pour la rétroaction des bits $D_0$ et $D_1$. On a alors un additionneur pour chaque bit (et on ne s'intéresse pas à la porte ET qui amène au calcul de $D_2$. Le détail du schéma logique est reporté en annexe \ref{incrementation}. Comme l'addition est effectuée sur chaque bit en un temps d'horloge, on incrémente effectivement le compteur d'une unité par cycle d'horloge : c'est le résultat attendu.\\
 Cependant, on peut directement simplifier ce montage avant d'effectuer le montage : la porte OU EXLUSIF de l'additionneur du bit $D_0$ avec une entrée à $1$ est simplifiable en NON, on se retrouve alors avec une double inversion que l'on peut supprimer. Une inversion simple du bit $D_0$ peut directement être obtenue avec la sortie $\overline{Q}$ de la dernière bascule. De même, la porte ET de l'additionneur du bit $D_0$ avec une entrée à $1$ recopie l'entrée et peut-être supprimée. On peut formellement démontrer ces simplifications dans l'algèbre booléen en utilisant des méthodes systématiques telles que les diagrammes de Karanaugh\citenotepage{Tocci}{108}. Le détail du schéma logique simplifié est détaillé en annexe \ref{incrementation-simplifie}.\\
 
-Dans un premier temps, le circuit a été mis en œuvre en réalisant les portes logiques à l'aide de composants électroniques fondamentaux tels que les résistances, diodes et transistors (on parle de logique DTL\footnote{Diode-Transistor Logic en Anglais, ou logique diode-transistor en Français}). Vu la quantité de composants nécessaires et la place requise, seul l'étage d'addition du bit $D_0$ a été réalisé, qui permet de valider la solution de synchronisation. Par ailleurs, cette expérience a été réalisée alors qu'aucun circuit de génération d'horloge n'était disponible : l'horloge a donc été émulée par un bouton poussoir relié à un état logique haut. La sortie est représentée par un LED, allumée pour signifier un état haut et éteinte pour un état bas.\\
+Dans un premier temps, le circuit a été mis en œuvre en réalisant les portes logiques à l'aide de composants électroniques fondamentaux tels que les résistances, diodes et transistors (on parle de logique DTL\footnote{Diode-Transistor Logic en Anglais, ou logique diode-transistor en Français}). Vu la quantité de composants nécessaires et la place requise, seul l'étage d'addition du bit $D_0$ a été réalisé, qui permet de valider la solution de synchronisation. Par ailleurs, cette expérience a été réalisée alors qu'aucun circuit de génération d'horloge n'était disponible : l'horloge a donc été émulée par un bouton poussoir relié à un état logique haut. La sortie est représentée par un LED, allumée pour signifier un état haut et éteinte pour un état bas. Une photographie du montage réalisé est reportée en annexe \ref{compteur-experimental}.\\
 
 Les premiers résultats indiquent que le circuit se comporte comme prévu, mais présente sporadiquement une anomalie : la LED clignote très rapidement au relâchement du bouton et indique l'état inverse à l'état attendu. Afin d'étudier le problème, on utilise un analyseur logique qui va enregistrer l'état de plusieurs points du circuit ($H, \overline{H}, Q,\overline{Q}, D_0, \overline{D_0}$)\footnote{$Q$ représente la sortie de la première bascule du circuit de synchronisation.} à une fréquence maximum de $24$ MHz. On effectue la capture en utilisant le logiciel \bsc{PulseView}, faisant partie de la suite d'outils libres \bsc{Sigrok}. Le chronogramme obtenu est reporté en annexe \ref{chronogramme-compteur} et on y observe l'anomalie après $1800$ ms. Un agrandissement de la zone en question, reporté en annexe \ref{chronogramme-compteur-bouton} permet de constater de très rapides oscillations du signal d'horloge : la partie logique du circuit se comporte finalement correctement, mais en des temps trop cours pour que l'on puisse l'observer. On émet l'hypothèse que cette gigue\footnote{fluctuation parasite rapide du signal} est le résultat d'un phénomène d'oscillation mécanique lié au bouton poussoir, ce-qui qui sera jugée comme vraisemblable par un professeur d'électronique de l'ENSEIRB-MATMECA. Il s'agit du phénomène de rebonds mécaniques, très courant dans l'utilisation de tels boutons.\\
 
@@ -273,13 +273,13 @@ C'est bien là le cœur du système que l'on a réalisé : il apparaît bien (en
 
 De la même façon, pour le second bit, on va souhaiter obtenir un état haut (bit égal à $1$) pendant une durée égale à deux périodes de l'horloge. En effet, pendant les deux premiers cycles d'horloge, le bit $D_0$ vaut successivement $0$ ($D=0$) puis $1$ ($D=1$), le bit $D_1$ prend alors la valeur $1$ alors que le bit $D_0$ vaut à nouveau $0$ ($D=2$) puis $1$ ($D=3$) et le bit $D_1$ prend alors à nouveau la valeur $0$ pendant les deux cycles suivants. Cette règle s'étend à $n$ bits et on va donc chercher à diviser la fréquence par deux à mesure que le poids du bit en question augmente.\\
 
-Une façon astucieuse de réaliser cette opération pour le bit de poids $n$ consiste à inverser la valeur précédente du bit à chaque cycle en utilisant comme horloge le bit $n-1$ : on divise alors par deux la fréquence de l'horloge d'entrée, ce-qui est le résultat souhaité. Il suffit alors d'utiliser l'horloge dont la période est l'unité de décompte du temps pour obtenir un compteur sur $n$ bits.\\
+Une façon astucieuse de réaliser cette opération pour le bit de poids $n$ consiste à inverser la valeur précédente du bit à chaque cycle en utilisant comme horloge le bit $n-1$ : on divise alors par deux la fréquence de l'horloge d'entrée, ce-qui est le résultat souhaité. Il suffit alors d'utiliser l'horloge dont la période est l'unité de décompte du temps pour obtenir un compteur sur $n$ bits. On pourrait d'ailleurs considérer l'horloge comme le premier bit et raisonner en demi périodes et doubles des fréquences (on préférera cependant distinguer l'horloge des bits dans un soucis de clarté). \\
 
 Ainsi, on pourra réaliser simplement un compteur sur $n$ bits en utilisant $n$ bascules synchronisées sur front d'horloge en inversant leur valeur à chaque cycle et en reliant la sortie de chaque bascule à l'entrée d'horloge de la suivante. Les bascules de type JK sont de telles bascules synchronisées et on peut obtenir une inversion en appliquant des états logiques hauts aux entrées J et K.\\
 
 On peut appliquer la même logique au montage de synchronisation que nous avons réalisé : on obtient alors le schéma reporté en annexe \ref{incrementation-final-nor}. On peut réaliser le même circuit en utilisant uniquement des portes NON-ET (il faut alors remplacer les portes ET par des portes NON-ET vu que les bascules à base de NON-ET sont à état logique bas actif) : on obtient le schéma reporté en annexe \ref{incrementation-final-nand}.\\
 
-On réalise ce montage fondamental $n$ fois pour $n$ bits en utilisant des portes NON-ET, qui sont disponibles en grande quantité et à faible coût (le composant TTL très répandu \bsc{7400}\citenote{Wikipedia7400} de \bsc{Texas Instruments} comporte 4 portes NON-ET en un seul circuit intégré).
+On réalise ce montage fondamental $n$ fois pour $n$ bits en utilisant des portes NON-ET, qui sont disponibles en grande quantité et à faible coût (le composant TTL très répandu \bsc{7400}\citenote{Wikipedia7400} de \bsc{Texas Instruments} comporte 4 portes NON-ET en un seul circuit intégré). Un photographie du montage réalisée est reportée en annexe \ref{compteur-final}.
 
 \section{Système complet modulable}
 
@@ -319,16 +319,12 @@ On réalise les horloges avec des composants (figure \ref{ne555-systemes}) NE555
 $$\alpha = 1 - \frac {R1} { (R2 + 2R1) } \approx 1 - \frac{R1}{2R1} = \frac12$$
 En pratique, on prendra pour $R2$ une valeur de 500 \ohm.\\
 
-Le premier montage est réalisé avec en entrée un horloge de fréquence environ égale à $1$ Hz, obtenue avec les valeurs des composants suivantes : $R1 = 72$ k\ohm\ et $C1 = 10$ \microf. On réalise le compteur sur $4$ bits, soit un décompte jusqu'à $15$ secondes. Le module de sortie, dont le schéma électronique du système est reporté en annexe \ref{systeme-led}, utilise un transistor NPN (avec un pont diviseur de tension) pour chaque LED, afin d'éviter que le courant nécessaire pour la LED ne passe par le circuit logique. De plus, On utilisera une résistance variable de l'ordre de $10$ k\ohm\ en série avec la LED pour régler la luminosité (et donc le courant consommé). Les valeurs nécessaires de résistance dépendront de la couleur de la LED et de l'intensité souhaitée.\\
+Le premier montage est réalisé avec en entrée un horloge de fréquence environ égale à $1$ Hz, obtenue avec les valeurs des composants suivantes : $R1 = 72$ k\ohm\ et $C1 = 10$ \microf. On réalise le compteur sur $3$ bits, soit un décompte jusqu'à $7$ secondes. Le module de sortie, dont le schéma électronique du système est reporté en annexe \ref{systeme-led}, utilise un transistor NPN (avec un pont diviseur de tension) pour chaque LED, afin d'éviter que le courant nécessaire pour la LED ne passe par le circuit logique. De plus, On utilisera une résistance variable de l'ordre de $10$ k\ohm\ en série avec la LED pour régler la luminosité (et donc le courant consommé). Les valeurs nécessaires de résistance dépendront de la couleur de la LED et de l'intensité souhaitée. On pourra remplacer cette résistance variable par une résistance de la valeur obtenue par expérimentation. Un photographie du montage réalisée est reportée en annexe \ref{systeme-led-photo}.\\
 
-+ref photo ici
-
-Pour le dernier système dont le schéma électronique est reporté en annexe \ref{systeme-alarme}, on souhaite tout d'abord faire clignoter une LED avec une période de $30$ secondes (pour attirer l'attention de l'usager), qui correspond à la période du signal d'horloge. On obtient cette période avec les composants suivants : $R1 = 98$ k\ohm et $C1 = 220$ \microf. On connecte donc la LED en série avec une résistance variable au travers d'un transistor (vu les considérations faites pour le premier montage) et la LED sera déclenchée avec l'état haut du signal d'horloge. Afin de détecter que les $3$ minutes sont écoulées, on s'intéresse aux bits $D_1$ et $D_2$. En effet, on veut un décompte jusqu'à six, exprimé $110$ en binaire : on teste donc les bits de poids 1 et 2, avec une porte logique ET. La sortie de cette porte est reliée à une bascule RS de sorte que dès que les bits de poids 1 et 2 sont à $1$, l'entrée S de la bascule soit activée et passe $Q$ à 1 et $\overline{Q}$ à 0. On relie alors la sortie de $\overline{Q}$ à l'alimentation $VH$ de l'horloge, de sorte que dès que les $3$ minutes sont écoulées, le décompte s'arrête. La sortie $Q$ de la bascule sera reliée à l'alimentation d'un multivibrateur astable réalisé avec un $NE555$ de période $1$ seconde (avec les valeurs déjà évoquées), dont la sortie est elle-même reliée à l'alimentation d'un second multivibrateur astable. Ce dernier multivibrateur, toujours réalisé avec un $NE555$ avec une fréquence adaptée pour commander un bipeur piézoélectrique, qui émet un son quand il est stimulé par une fréquence proche de sa fréquence de résonance, de l'ordre de quelques kHz. On ne connaît pas la fréquence de résonance précise du composant utilisé : on utilisera alors une résistance variable pour déterminer expérimentalement une valeur qui produit un son satisfaisant.\\
+Pour le dernier système avec compteur sur 3 bits, dont le schéma électronique est reporté en annexe \ref{systeme-alarme}, on souhaite tout d'abord faire clignoter une LED avec une période de $30$ secondes (pour attirer l'attention de l'usager), qui correspond à la période du signal d'horloge. On obtient cette période avec les composants suivants : $R1 = 98$ k\ohm\ et $C1 = 220$ \microf. On connecte donc la LED en série avec une résistance (variable ou non) au travers d'un transistor (vu les considérations faites pour le premier montage) et la LED sera déclenchée avec l'état haut du signal d'horloge. Afin de détecter que les $3$ minutes sont écoulées, on s'intéresse aux bits $D_1$ et $D_2$. En effet, on veut un décompte jusqu'à six, exprimé $110$ en binaire : on teste donc les bits de poids 1 et 2, avec une porte logique ET. La sortie de cette porte est reliée à une bascule RS de sorte que dès que les bits de poids 1 et 2 sont à $1$, l'entrée S de la bascule soit activée et passe $Q$ à 1 et $\overline{Q}$ à 0. On relie alors la sortie de $\overline{Q}$ à l'alimentation $VH$ de l'horloge, de sorte que dès que les $3$ minutes sont écoulées, le décompte s'arrête. La sortie $Q$ de la bascule sera reliée à l'alimentation d'un multivibrateur astable réalisé avec un $NE555$ de période $1$ seconde (avec les valeurs déjà évoquées), dont la sortie est elle-même reliée à l'alimentation d'un second multivibrateur astable. Ce dernier multivibrateur, toujours réalisé avec un $NE555$ avec une fréquence adaptée pour commander un bipeur piézoélectrique, qui émet un son quand il est stimulé par une fréquence proche de sa fréquence de résonance, de l'ordre de quelques kHz. On ne connaît pas la fréquence de résonance précise du composant utilisé : on utilisera alors une résistance variable pour déterminer expérimentalement une valeur qui produit un son satisfaisant, que l'on pourra remplacer par une résistance de la valeur obtenue.\\
 
 Pour ce dernier multivibrateur, on utilise un condensateur de $0,22$ \microf\ et une résistance $R8 = 500$ \ohm. On trouve alors des fréquences de l'ordre de quelques kHz pour des valeurs de $VR2$ de l'ordre de l'ordre de quelques k\ohm. De cette façon, on entendra un son émis en alternance sur une fréquence de $1$ Hz, qui correspondra à l'alarme sonore. Le bipeur est connecté à la sortie du dernier multivibrateur au travers d'un transistor (même considération que pour la LED) avec une résistance variable en série, pour contrôler son volume (et donc la consommation en courant).\\
 
-L'alarme sonore pourra être désactivée avec un bouton poussoir, relié d'une part au 5V et d'autre part à l'entrée R de la bascule RS, qui réinitialisera le système en plaçant l'état $Q$ à 0 et $\overline{Q}$ à 1 (l'horloge redémarre, les deux autres multivibrateurs ne sont plus alimentés). On remarque que les rebonds du bouton ne sont pas importants puisque seul un état haut sera actif sur l'entrée R (on réalisé un bascule à base de portes NON-OU/NI). Afin d'éviter un état indéterminé quand le bouton n'est pas pressé, on relie l'entrée R de la bascule à la masse, avec un faible résistance (on prendra $R5 = 500$\ohm).\\
-
-+ref photo ici
+L'alarme sonore pourra être désactivée avec un bouton poussoir, relié d'une part au 5V et d'autre part à l'entrée R de la bascule RS, qui réinitialisera le système en plaçant l'état $Q$ à 0 et $\overline{Q}$ à 1 (l'horloge redémarre, les deux autres multivibrateurs ne sont plus alimentés). On remarque que les rebonds du bouton ne sont pas importants puisque seul un état haut sera actif sur l'entrée R (on réalisé un bascule à base de portes NON-OU/NI). Afin d'éviter un état indéterminé quand le bouton n'est pas pressé, on relie l'entrée R de la bascule à la masse, avec un faible résistance (on prendra $R5 = 500$\ohm). Un photographie du montage réalisée est reportée en annexe \ref{systeme-alarme-photo}.\\
 
 Expérimentalement, on pourra ajuster les valeurs des composants choisis, qui ne correspondent pas exactement aux valeurs indiquées (par exemple, un condensateur peut perdre de sa charge après un certain temps d'utilisation). Les composants utilisés ne sont d'ailleurs pas tous neufs : une grande partie provient de récupération sur des circuits quelconques.
index 096133a..dc9e67a 100644 (file)
@@ -20,7 +20,7 @@ De la même façon qu'il est nécessaire de synchroniser certains types de circu
 \caption{La carte Cubieboard2}
 \end{figure}
 
-La carte Cubieboard2\citenote{Cubieboard} est un exemple particulier d'ordinateur complet. On retrouve en effet tous les composants constituants un ordinateur sur une carte de petite taille. Le processeur est intégré au sein d'une puce de type SoC\footnote{System on a Chip en Anglais, soit système sur une puce en Français} : il s'agit d'un seul circuit intégré rassemblant, en plus du processeur principal, un certain nombre d'autres composants utiles tels que diverses entrées sorties, des processeurs auxiliaires, etc. Pour autant, il ne contient pas la mémoire principal de l'ordinateur : il ne s'agit donc pas d'un microcontrôleur. Le SoC utilisé dans la Cubieboard2 est un \bsc{A20} produit par la société chinoise \bsc{Allwinner}. Le processeur utilisé dans le \bsc{A20} est un \bsc{Cortex A7}, qui utilise un jeu d'instructions \bsc{ARM} et opère avec un fréquence d'horloge de $1$ GHz.\\
+La carte Cubieboard2\citenote{Cubieboard} est un exemple particulier d'ordinateur complet. On retrouve en effet tous les composants constituants un ordinateur sur une carte de petite taille : on parle d'ordinateur à carte unique, de l'Anglais \emph{Single Board Computer}, parfois abrégé par ses initiales : \emph{SBC}. Le processeur de l'ordinateur est intégré au sein d'une puce de type SoC\footnote{System on a Chip en Anglais, soit système sur une puce en Français} : il s'agit d'un seul circuit intégré rassemblant, en plus du processeur principal, un certain nombre d'autres composants utiles tels que diverses entrées sorties, des processeurs auxiliaires, etc. Pour autant, il ne contient pas la mémoire principal de l'ordinateur : il ne s'agit donc pas d'un microcontrôleur. Le SoC utilisé dans la Cubieboard2 est un \bsc{A20} produit par la société chinoise \bsc{Allwinner}. Le processeur utilisé dans le \bsc{A20} est un \bsc{Cortex A7}, qui utilise un jeu d'instructions \bsc{ARM} et opère avec un fréquence d'horloge de $1$ GHz.\\
 
 \begin{figure}[!h]
 \centering
@@ -83,7 +83,7 @@ Au sein de la Cubieboard2, la communication avec le circuit intégré responsabl
 \item[--] Avec résistances de rappel au niveau haut\\
 \end{itemize}
 
-La ligne de données est notée $SDA$ et la ligne d'horloge $SCL$. Le schéma électrique de connexion de l'\bsc{AXP209} au SoC est détaillé avec la figure \ref{axp209} :
+La ligne de données est notée $SDA$ et la ligne d'horloge $SCL$. Le schéma électrique\citenote{CubieboardDiagram} de connexion de l'\bsc{AXP209} au SoC est détaillé avec la figure \ref{axp209} :
 
 \begin{figure}[!h]
 \centering
@@ -92,9 +92,9 @@ La ligne de données est notée $SDA$ et la ligne d'horloge $SCL$. Le schéma é
 \label{axp209}
 \end{figure}
 
-On souhaite alors faire communiquer la Cubieboard2 avec le microcontrôleur Arduino, en utilisant le bus et le protocole \iic. La Cubieboard2 dispose de 5\footnote{Ref sur leA20 datasheet} composants dédiés à la gestion du bus \iic\ intégrés au sein de son SoC : il s'agit de contrôleurs \iic\ \bsc{Marvell MV64xxx}\footnote{Référence biblio: http://linux-sunxi.org/Used_IP_cores}. L'Arduino ne dispose par contre pas de contrôleur intégré. Il va s'agir d'implémenter la gestion du protocole \iic\ dans un programme qui sera exécuté sur l'Arduino, en utilisant deux lignes numériques d'entrée/sortie dont dispose le microcontrôleur de l'Arduino : ils'agit de la technique dite de bit banging.\\ Ces lignes d'entrée/sortie se comportent d'après la logique trois états, avec un état haut, un état bas et un état hi-Z qui permettra la lecture. On pourra configurer le mode de chaque ligne avec des instructions. Les entrées/sorties sont plus précisément contrôlées en écrivant à des adresses mémoire précises (on parle de MMIO\footnote{Memory-Mapped Input/Output en Anglais, soit entrée/sortie cartographiée en mémoire en Français}) plutôt qu'avec des instructions directes pour le processeur (on parle de PIO\footnote{Programmed Input/Output en Anglais, soit entrée/sortie programmée en Français}).\\
+On souhaite alors faire communiquer la Cubieboard2 avec le microcontrôleur Arduino, en utilisant le bus et le protocole \iic. La Cubieboard2 dispose de 5\citenote{A20UserManual} composants dédiés à la gestion du bus \iic\ intégrés au sein de son SoC : il s'agit de contrôleurs \iic\ \bsc{Marvell MV64xxx}\citenote{AWIPCores}. L'Arduino ne dispose par contre pas de contrôleur intégré. Il va s'agir d'implémenter la gestion du protocole \iic\ dans un programme qui sera exécuté sur l'Arduino, en utilisant deux lignes numériques d'entrée/sortie dont dispose le microcontrôleur de l'Arduino : ils'agit de la technique dite de bit banging.\\ Ces lignes d'entrée/sortie se comportent d'après la logique trois états, avec un état haut, un état bas et un état hi-Z qui permettra la lecture. On pourra configurer le mode de chaque ligne avec des instructions. Les entrées/sorties sont plus précisément contrôlées en écrivant à des adresses mémoire précises (on parle de MMIO\footnote{Memory-Mapped Input/Output en Anglais, soit entrée/sortie cartographiée en mémoire en Français}) plutôt qu'avec des instructions directes pour le processeur (on parle de PIO\footnote{Programmed Input/Output en Anglais, soit entrée/sortie programmée en Français}).\\
 
-Afin de relier les deux systèmes, on cherchera à connecter deux lignes, entre deux entrées/sorties numériques de l'Arduino et des connecteurs reliés aux points $SDA$ et $SCL$ de la Cubieboard2. Si les entrées/sorties numériques de l'Arduino sont disponibles en grande quantité, seul le contrôleur \iic\ identifié par l'index 1 est accessible par les connecteurs externes de la carte (dans la littérature spécifique au SoC \bsc{A20}, il est appelé $TWI1$\footnote{Two Wire Interface en Anglais, soit interface à deux fils en Français, terme équivalent à \iic.}). On relie alors les connecteurs reliés à $TWI1-SDA$ et $TWI1-SCK$\footnote{Référence : http://linux-sunxi.org/Cubieboard/ExpansionPorts}à l'Arduino.\\
+Afin de relier les deux systèmes, on cherchera à connecter deux lignes, entre deux entrées/sorties numériques de l'Arduino et des connecteurs reliés aux points $SDA$ et $SCL$ de la Cubieboard2. Si les entrées/sorties numériques de l'Arduino sont disponibles en grande quantité, seul le contrôleur \iic\ identifié par l'index 1 est accessible par les connecteurs externes de la carte (dans la littérature spécifique au SoC \bsc{A20}, il est appelé $TWI1$\footnote{Two Wire Interface en Anglais, soit interface à deux fils en Français, terme équivalent à \iic.}). On relie alors les connecteurs reliés à $TWI1-SDA$ et $TWI1-SCK$\footnote{Référence : http://linux-sunxi.org/Cubieboard/ExpansionPorts}à l'Arduino. Une photographie des deux cartes connectées est reporté en annexe \ref{ardui2c-photo}.\\
 
 \subsubsection*{\bsc{U-Boot} et prise en charge du contrôleur \iic\ $TWI1$}
 
@@ -137,7 +137,6 @@ Valid chip addresses: 42
 L'adresse 0x42\footnote{Le préfixe $0x$ indique l'utilisation de la base 16, c'est donc $66$ en décimal.} est bien l'adresse attribuée à l'Arduino.\\
 
 On pourra alors lire les 5 premiers registres :
-+TODO avec 4
 \begin{verbatim}
 sunxi# i2c md 0x42 0x00 0x5
 0000: 43 50 42 78 00    CPBx
@@ -168,8 +167,126 @@ On relève également l'activité sur le bus avec l'analyseur logique et le logi
 * Au bout d'un moment, ça pose problème
 * Du coup on a plusieurs coeurs en même temps => parallelisme
 + def multi-threading avec rapport au multi-processus
+FIL d'EXECUTION PLZ
+
+\section{Optimisation des temps d'exécution des programmes}
+
+\subsection{Efficacité du traitement algorithmique et complexité}
+
+La vitesse d’exécution d'un algorithme dépend du \og coût\fg{} de ses opérations, chaque opération de base nécessitant un certain temps de calcul par le processeur. Il existe une science informatique théorique et mathématique, qui étudie le coût en temps et ressources d'un algorithme pour résoudre un problème donné : la \emph{théorie de la complexité}. La \emph{complexité} d'un algorithme est une grandeur abstraite, c'est une fonction qui mesure le nombre d'opérations de base effectuées en fonction d'un paramètre $n$ (ce paramètre peut par exemple être la taille d'une liste), ou plus généralement qui caractérise la \og taille\fg{} d'un problème. La complexité mesure l'ordre de grandeur du coût algorithmique pour des grandes valeurs de $n$, généralement on la compare à une autre fonction mathématique dont le comportement en l'infini est similaire. On utilise pour cela les notations de \bsc{landau} : O, $\Omega$ ou $\theta$. \\
+
+On rappelle les définitions mathématiques de ces différentes notations. Considérons deux fonctions $f:\R\mapsto\R$ et $g:\R\mapsto\R$ ainsi que deux constantes $(C_1,C_2)\in\R^2$. On a :
+\begin{itemize}
+       \item[--] on dit que $f$ est \emph{dominée} par $g$ quand $x$ tend vers l'infini si : \[\exists A\in\R,\ \forall x\in\R,\ x\geq A\ \Rightarrow\ |f(x)|\leq C_1|g(x)|\]
+       On note alors : $f=O(g)$. Visuellement cela signifie que les variations en l'infini de $f$ sont conditionnées par celles de $g$.
+       \item[--] on note $f=\Omega(g)$ si : \[\exists A\in\R,\ \forall x\in\R,\ x\geq A\ \Rightarrow\ C_1|g(x)|\leq|f(x)|\]
+       \item[--] on note $f=\theta$ si $f=O(g)$ et $f=\Omega(g)$, i.e si : \[\exists A\in\R,\ \forall x\in\R,\ x\geq A\ \Rightarrow\ C_1|g(x)|\leq|f(x)|\leq C_2|g(x)|\]
+\end{itemize}
+
+C'est une notion très formelle et qui se base sur une unité arbitraire, on ne mesure pas réellement un temps, mais plutôt un nombre d'opérations élémentaires effectuées qui peuvent être par exemple : une comparaison de deux variables, un test binaire, une opération arithmétique, la création ou la modification d'une variable. Chaque opération coûte une unité, on peut ainsi en étudiant l'algorithme déduire une loi formelle qui définit sont comportement pour une taille initiale $n$, souvent notée $\mathcal{C}(n)$. L'étude de la complexité d'un algorithme permet d'évaluer son efficacité, plus la vitesse de convergence de $\mathcal{C}$ est lente et plus l'algorithme est efficace : un algorithme de complexité linéaire ($\mathcal{C}(n)=\theta(n)$) sera préféré à un algorithme de de complexité polynomiale (par exemple $\mathcal{C}(n)=\theta(n^2)$), tandis qu'un algorithme de complexité logarithmique ($\mathcal{C}(n)=\theta(\log(n))$) sera préféré à un autre de complexité linéaire.\\
+
+Cette grandeur est donc une grandeur à considérer pour l'optimisation du temps d'exécution d'un programme. En effet, plusieurs solutions algorithmiques de complexités différentes peuvent exister pour un problème quelconque et il ne tiendra bien souvent qu'à l'inventivité du programmeur pour trouver une solution encore meilleure.\\
+
+Cependant, bien qu'un algorithme puisse être perfectible, sa vitesse d’exécution sera toujours limitée par les capacités matérielles de la machine sur laquelle on le lance. En effet, le processeur d'un ordinateur traite un certain nombre d'opérations (ou instructions) les unes à la suite des autres, cadencé par une horloge. Certains processeurs disposent d'instructions particulières, qui combinent parfois plusieurs opérations élémentaires en une(c'est par exemple le cas des extensions \bsc{NEON} dans les processeurs \bsc{ARM} tels que celui de la Cubieboard2.\\
+
+ Le temps d’exécution d'un programme peut donc dépendre des paramètres suivants :
+\begin{itemize}
+       \item[--] les extensions utilisées pour les instructions
+       \item[--] les optimisations effectuées par le compilateur (par exemple, certaines opérations sont redondantes et peuvent-être éliminées durant la phase d'optimisation), afin de réduire le nombre d'instructions
+       \item[--] le nombre de $n$ d'instructions qui doivent être exécutées 
+       \item[--] le nombre $c$ moyen de cycles d'horloges (aussi abrégé $CPI$ : de l'anglais \emph{Cycle Per Instruction}) que nécessite une instruction : ce nombre dépend donc de la complexité de l'instruction, i.e comme vu précédemment, du nombre d'accès mémoire, des opérandes utilisées, ...
+       \item[--] la période $\tau$ d'un cycle d'horloge du processeur
+\end{itemize}\\
+
+Le temps d'exécution $T_e$ d'un processus peut ainsi être déterminé grâce à l'équation :
+\begin{equation}
+T_e=nc\tau
+\label{eq:tempsexec}
+\end{equation}
+% Evolution architecture ordinateur Google Livres
+
+L'amélioration des performances passe donc nécessairement par un travail sur ces facteurs. Autant les valeurs $n$ et $c$ dépendent de l'algorithme, autant la données $\tau$ intrinsèque au matériel utilisé. Comme on a $\tau=\frac{1}{f}$ (où $f$ est la fréquence d'horloge du processeur), l'enjeu est d'augmenter la valeur de $f$ afin de diminuer le temps d'exécution des programmes. La fréquences est dépendant de la taille et du nombre de composants qui composent une unité de calcul, plus précisément les transistors qui constituent la \og brique\fg{} essentielle d'un processeur. La miniaturisation des transistors permet d'en augmenter leur densité surfacique sur un circuit intégré, et donc d'améliorer la fréquence d'horloge.\\ L'ingénieur américain Robert \bsc{Dennard} apporta une énorme contribution en mettant au point une méthode permettant de diminuer la taille des transistors et ainsi d'en d'augmenter la rapidité. L'évolution du nombre de transistors par unité de surface dans un processeur suit la loi de \bsc{Moore} : c'est une loi exponentielle qui prévoit le doublement des performances tous les 18 mois.
+
+\subsection{Limites à la montée en fréquence et parallélisme}
+
+La méthode d'augmentation des fréquence a pu porter ses fruits pendant quelques années, et permet effectivement d'améliorer les performances des processeurs. En revanche, il devient de plus en plus difficile d'améliorer les fréquences, et à partir des années 2000 il a fallu commencer à s'orienter vers d'autres moyens pour rendre les processeurs plus performants. Les causes de ces limitations à la montée en fréquence sont multiples, et la majorité sont liés à des phénomènes physiques problématiques.
+
+Premièrement, la miniaturisation des transistors à amener à la diminution des dimensions des fils d'interconnexion. Or le \emph{temps d'interconnexion}, c'est-à-dire le temps nécessaire pour le l'information transite d'un transistor à un autre, reste globalement constant. La finesse atteinte dans la gravure des processeurs ne permet donc plus à l'information de se propager, en effet distance et temps sont liés par la vitesse de propagation du signal électrique.
+% chiffres pour illustrer ?
+
+Ensuite, le second problème est d'ordre énergétique, en effet un transistor consomme de l'énergie (et en dissipe) à chaque commutation, ainsi on peut facilement voir que la consommation électrique et la dissipation d'énergie sont proportionnelles aux produit du nombre de transistor dans le circuit par la fréquence de l'horloge. Avec des grandes fréquences, les processeurs sont gourmands en énergie et en dissipent beaucoup sous forme de chaleur : ils s'échauffent et sont de plus en plus compliqué à refroidir. Les systèmes de refroidissement à air utilisés dans les ordinateurs personnels ne suffisent plus.
+
+Dernièrement, on a vu que la fréquence a rapidement augmenté, en revanche la fréquence de la mémoire n'a pas suivi la même évolution. La différence entre ces deux quantités devient tellement importante que la fréquence du processeur ne peut être exploitée par la mémoire : en phase de lecture ou d'écriture de la mémoire, beaucoup de cycles d'horloges sont gâchés car il ne se passe rien.
+
+Comme le facteur $\tau$ ne peut plus être beaucoup diminué, dans l'équation \eqref{eq:tempsexec} l'idée est de tenter de réduire le nombre $c$ de cycles par instruction. Pour cela on peut choisir d'augmenter le nombre d'instruction qui s'exécutent simultanément. La solution qui a été adoptée est le concept de \emph{parallélisme}, dont l'idée principale est d'exécuter différentes séquence d'instructions en même temps. Un processeur qui est capable de gérer des instructions simultanées est dit \emph{multithread}. On peut intégrer cette méthode de façon logicielle ou bien matérielle. 
+
+Le principe est de pouvoir gérer différents fils d'exécution (ou \emph{thread} en anglais) en même temps, 
+
+%pdf mec LABRI (sur portable)
+* Au bout d'un moment, ça pose problème
+* augmenter le CPI
+* Du coup on a plusieurs coeurs en même temps => parallelisme
++ def multi-threading avec rapport au multi-processus
+* diminue énergie dissipée par effet Joule
+
+
+
 \subsection{Explicitation du gain en efficacité et contraintes}
-+ et bah la cubieboard2 elle est multicoeur et que pas la cubieboard1!
-* Conception de programmes parallèles c'est mieux, plus rapide => encodage + single coeur, 4 coeurs, cremi!
-* cependant tous les algos de s'y prètent pas (diviser pour régner c'est le cas)
-* Contraintes de synchronisation
+
+Les ordinateurs utilisant des processeurs multi-cœurs sont désormais très courants sur le marché et de nos jours, il s'agit même de la norme. Ce n'est pas seulement le cas sur les ordinateurs traditionnels, puisque les appareils mobiles tels que les smartphones ou les tablettes sont également dotés de processeurs multi-cœurs. C'est de même le cas pour différents autres formats d'ordinateurs, y compris les ordinateurs à carte unique tels que la Cubieboard2. La Cubieboard2 est d'ailleurs la seconde itération de la série Cubieboard, utilisant un SoC \bsc{A20} à deux cœurs alors que la première itération utilise un SoC \bsc{A10} monocœur. La Cubieboard2 est donc également intéressante du point de vue du parallélisme.\\
+
+Cependant, si la multiplicité des cœurs permet d'exécuter plusieurs programmes réellement en simultané, il est courant qu'un seul programme requiert toutes les capacités de la machine tant la tâche qu'il accomplie complexe. Si ce programme n'est pas prévu pour fonctionner sur plusieurs fils distincts, le calcul ne sera effectué que sur un seul cœur et l'avantage du multi-cœur sera en grande partie perdu, si ce n'est que le autres cœurs permettront de garantir une utilisation fluide du système pendant ce calcul lourd. Il est cependant bien souvent souhaitable de réduire la durée du calcul au détriment de l'utilisabilité immédiate de l'ordinateur.\\
+
+On va donc chercher à écrire et utiliser des programmes utilisant le nombre maximal de cœurs disponibles, ou pour le moins qui offrent à l'utilisateur cette possibilité, bien souvent en lui permettant de choisir le nombre de fils d'exécution (qui seront répartis sur les différents cœurs) à utiliser. Néanmoins, tous les algorithmes de ne prêtent pas forcément bien à un découpage en plusieurs fils s'exécutant sur plusieurs cœurs simultanément. En effet, exécuter plusieurs calculs en parallèle suppose que ces calculs sont indépendants entre eux. Hors, le cas général est plutôt le traitement d'un problème avec des étapes logiques qui dépendent respectivement des étapes précédentes. Il n'est donc pas toujours possible de paralléliser les calculs. Certaines grandes familles d'algorithmes pourront au contraire bien s'y prêter, comme c'est le cas des algorithmes de type « diviser pour régner » qui découpent les problèmes en sous-problèmes indépendants plus petits. On pourra alors traiter chaque sous problème sur un cœur séparé. Il est cependant inévitable de rassembler les calculs effectués en parallèle afin d'obtenir un résultat cohérent. Selon les problèmes, cette étape peut être triviale ou au contraire prendre un temps signification, qui ne pourra être effectué que sur un cœur.\\
+
+Expérimentalement, on va relever le gain en temps lié à l'utilisation de plusieurs fils d'exécution (répartis sur les différents cœurs) en encodant\footnote{Il s'agit de changement de format numérique.}, opération bien connue pour être demandant en calculs, qui sont liés aux opérations de décompression et de compression des images (et de manière moindre, du son). On effectue tout d'abord l'opération sur la Cubieboard2 en précisant au programme d'encodage \bsc{avconv} de n'utiliser qu'un seul fil d'exécution. Le temps d'exécution du programme est alors de \textbf{4 minutes et 41,509 secondes}. En précisant au programme d'utiliser deux fils d'exécutions (un pour chaque cœur du processeur), on obtient alors un temps d'exécution de \textbf{2 minutes et 53,528 secondes}, soit une réduction du temps de presque moitié : l'utilisation de plusieurs fils prouve donc son efficacité.\\
+
+On effectue alors la même expérience avec ordinateur portable, équipé d'un processeur \emph{Intel i7-3630QM}. Pour la même vidéo, le temps d'encodage est de \textbf{25,536 secondes} avec un seul fil, \textbf{15,883 secondes} avec 2 fils et \textbf{15,797 secondes} avec l'ensemble des 8 fils (un pour chaque cœur disponible). On constate bien un gain en temps lors de l'utilisation de deux fils plutôt qu'un seul, mais il n'y a pas de différence avec l'utilisation de 8 fils plutôt que de deux. On s'intéresse alors aux relevés d'utilisation des cœurs durant l'opération, reportés en annexe \ref{encodage}. Avec un fil, un cœur est sollicité en permanence (100\%) alors que dans les deux autres cas, l'utilisation des cœurs n'est jamais maximum. On suppose donc qu'il s'agit d'un algorithme qui présente des limites à la parallélisation, si on exclut tout autre facteur limitant l'efficacité (comme le temps de lecture et d'écriture des données sur le disque, par exemple). Cette caractéristique peut être spécifique à l'un des formats vidéo mis en jeu dans l'encodage. Les formats vidéo récents sont conçus pour être fortement parallélisables pour que les performances d'encodage (et de décodage) puissent augmenter avec le nombre de cœurs disponibles.\\
+
+Si l'utilisation de plusieurs fils d'exécutions (qui seront répartis sur plusieurs cœurs avec un processeur qui le permet) peur présenter des avantages d'efficacité, cela impose l'utilisation de certaines techniques de synchronisation des données au sein du programme réalisé. C'est ce type de contrainte que l'on souhaite mettre en évidence avec la réalisation d'un court programme, écrit en langage C qui utilise deux fonctions, exécutées dans deux fils d'exécutions distincts (gérés avec la librairie standard \bsc{pthread}) :
+\begin{itemize}
+\item[--] La fonction principale $main$, qui initialise les données utilisées par le programme, démarre le second fil d'exécution et calcule une moyenne de $n$ valeurs stockées dans un tablea.
+\item[--] Une fonction $thread\_random$ exécutée dans un second fil, qui tire des nombres aléatoires et les stocke dans un tableau.\\
+\end{itemize}
+
+Le programme est tout d'abord écrit sans se soucier de synchronisation entre les fils d'exécution. Le code source du programme est reporté en annexe \ref{thread} et certains aspects techniques non-directement liés au propos sont explicités sous la forme de commentaires dans le code.\\
+
+Afin de stocker les données, on définit une structure $struct data$ contenant le nombre $n$ de valeurs tirées et un tableau de 10 entiers. La valeur maximum de $n$ sera donc 10 et sera réinitialisée à 0 tous les 10 tirages. Le fil d'exécution principal (fonction $main$) va donc vérifier que la valeur $n$ n'est pas nulle avant de calculer la moyenne, qui implique une division par $n$. En effet, une division par zéro causerait une erreur d'exécution du programme (dite erreur de segmentation) qui cause l'arrêt complet et irrécupérable de son exécution.\\
+
+On compile alors le programme (avec le compilateur \bsc{gcc}) et on constate qu'après avoir affiché un nombre aléatoire (mais généralement assez faible) de moyennes calculées, l'exécution est interrompue par une erreur d'exécution. La sortie du programme affiche :
+\begin{verbatim}
+Moyenne : 0
+Moyenne : 1003350165
+Moyenne : 1005956119
+Moyenne : -160953016
+Moyenne : -728591323
+Moyenne : 957108031
+Moyenne : 6270017
+Moyenne : -522201508
+Moyenne : -2025419578
+Exception en point flottant
+\end{verbatim}
+
+En effet, cet erreur traduit une division par zéro, effectuée à la ligne 87, même si la valeur $n$ a été vérifiée comme différente de zéro avant cette opération. En effet, comme les deux fils d'exécution sont exécutés en même temps (ou dans le cas d'un processeur à un seul cœur, alternativement, mais le découpage du temps d'exécutions attribué à chaque fil n'est pas prédictible pour le programmeur), il est possible que le second fil d'exécution change la valeur de $n$ entre le test avec zéro et l'opération effectivement effectuée. Par exemple, si on a $n=9$ au moment du test, puis le second fil s'exécute et tire un dixième nombre, réinitialisant $n$ à 0, la division sur le premier fil sera effectuée avec $n = 0$.\\
+
+Afin de palier à ce problème, on introduit la notion de blocage des fils d'exécution. Il s'agit de fonctions de blocage et de déblocage liés à une variable de type mutex\acrotrad{Mutual exclusion}{exclusion mutuelle}, définies dans la librairie \bsc{pthread} et qui fonctionnent comme suit\citenote{pthread} :
+\begin{itemize}
+\item[--] Un premier appel à la fonction de blocage $pthread\_mutex\_lock$ passe la variable mutex à un état bloqué et l'exécution du fil d'exécution appelant continue.
+\item[--] Un second appel à la fonction de blocage $pthread\_mutex\_lock$ (avec la variable mutex dans un état bloqué) bloque l'exécution du fil d'exécution appelant.
+\item[--] Une appel à la fonction de déblocage $pthread\_mutex\_unlock$ passe la variable mutex à un état débloqué et débloque l'exécution des fils bloqués par ce mutex.\\
+\end{itemize}
+
+Ce mécanisme va donc permettre de bloque l'un des fils d'exécution quand des données communes aux deux fils sont utilisés, ce-qui n'empêchera pas les fils d'effectuer certains actions (comme l'affichage de la moyenne calculée) indépendamment du blocage. Ainsi, on modifie le code source du programme en y insérant des appels à $pthread\_mutex\_lock$ avant les blocs de code utilisant les données communes et des appels à $pthread\_mutex\_unlock$ après. Les modifications apportées au code sont reportées en annexe \ref{thread-diff}.\\
+
+On constate dès lors que l'exécution du programme se déroule sans encombres et des valeurs sont affichées continuellement, sans erreur :
+\begin{verbatim}
+Moyenne : -248157731
+Moyenne : -47172384
+Moyenne : -1019308425
+Moyenne : 181912522
+Moyenne : -108999156
+Moyenne : 488697234
+Moyenne : 338524137
+\end{verbatim}
+
+L'utilisation des mutex reste néanmoins un sujet sensible dans l'écriture de code source, en particulier à cause de problèmes d'auto-blocage ou d'inter-dépendances. Dans le premier cas, il s'agit de plusieurs appels successifs à $pthread\_mutex\_lock$ dans le même fil d'exécution, ce-qui a pour effet de bloquer ce fil sans qu'il ne soit garanti qu'un autre fil puisse le débloquer. En particulier, si les parties du code à protéger des autres fils sont entourées d'appels à $pthread\_mutex\_lock$ et $pthread\_mutex\_unlock$, les fils seront tous bloqués avant de pour débloquer ce premier fil, ce-qui aboutit à un programme irrémédiablement bloqué dans sa globalité. Dans le second cas, il s'agira de l'utilisation de plusieurs mutex distincts avec au moins deux fils d'exécution, chacun bloquant un mutex et attendant le déblocage de l'autre mutex (les appels à $pthread\_mutex\_lock$ seront donc dans l'ordre inversé sur les deux fils d'exécution), ce-qui aboutit au blocage des deux fils, irrémédiable s'il n'existe pas d'autre fil capable d'appeler $pthread\_mutex\_unlock$ pour débloquer l'ensemble.
index 0dfb184..42f7287 100644 (file)
@@ -7,12 +7,10 @@ Pourtant, le choix de cette thématique ne s'est pas limité à un ensemble de c
 
 Au cours de ce sujet, on souhaite donc mettre en évidence de quelle manière le temps est représenté en électronique (mais également quels systèmes de représentation du temps ont précédé à l'électronique) et par quels procédés il est quantifié. De plus, on s'intéresse aux systèmes électroniques qui ont recours à la quantifications du temps pour répondre à diverses problématiques que l'on cherchera à expliciter mais également aux contraintes supplémentaires que l'utilisation du temps introduit. Il s'agit en effet de fournir une compréhension de ces phénomènes.\\
 
-Notre démarche provient initialement d'un questionnement vis à vis d'un système complexe tel qu'un ordinateur. En particulier, nous avons choisi d'aborder l'étude d'un ordinateur à carte unique : la Cuebieboard2, ordinateur complet au format physique réduit (de l'ordre de la taille d'une carte de crédit). On s'intéressera aux aspects liés au temps de ce système à la fois du point de vue électronique et du point de vue informatique : il s'agit du fil conducteur de notre étude.\\
+Notre démarche provient initialement d'un questionnement vis à vis d'un système complexe tel qu'un ordinateur. En particulier, nous avons choisi d'aborder l'étude d'un ordinateur à carte unique : la Cuebieboard2, ordinateur complet au format physique réduit (de l'ordre de la taille d'une carte de crédit). On s'intéressera aux aspects liés au temps de ce système à la fois du point de vue électronique et du point de vue informatique : il s'agit du fil conducteur de notre étude. Notre étude est par ailleurs l'occasion d'aborder certains grands aspects des domaines en question, comme la logique booléenne en électronique ou le parallelisme en informatique.\\
 
-\vfill
+En plus de l'étude ponctuelle de ce système, on propose de réaliser différentes expériences. D'une part, on cherchera à réaliser différents montages et programmes informatiques pour mettre en évidence un procédé ou la nécessité d'un concept et d'autre part, on réalisera un certain nombre de systèmes complets, qui ont une application pratique directe détachée des domaines d'ingénierie qui nous concernent. Il s'agit alors de démontrer la présence des concepts liés aux système électroniques numériques et au temps dans la vie courante.\\
 
-+intérets pour nous, motivations, choix du sujet
-+Qu'est-ce qu'on veut montrer et comment on s'y prend
-+Questions qu'on s'est posé au début
-+Présenter la Cubieboard et Arduino
-+Présentation des modules
+Notre étude, si elle est fondamentalement constituée en une démarche de recherche et d'explicitation s'appuie en partie sur des connaissances personnelles. Celles-ci auront bien souvent été acquises au fil du temps, avant même notre intégration au sein du Cycle Préparatoire de Bordeaux, traduisant ainsi notre intérêt de longue date pour ces domaines. Évidemment, ces connaissances ne sauraient se substituer à une recherche documentaire, réalisée afin de cerner l'ensemble des aspects développés et d'en préciser notre connaisance.\\
+
+C'est donc à la fois avec un intérêt personnel partagé et une volonté d'approfondir nos connaissances dans ces domaines, qui seront nos sujets d'études, que nous abordons ce projet.
index fddcae5..35318fd 100644 (file)
@@ -1,11 +1,3 @@
-@book{Tocci,\r
-title={Circuits numériques : théorie et applications},\r
-author={Tocci, R.J.},\r
-isbn={9782100033645},\r
-year={1996},\r
-publisher={Dunod}\r
-}\r
-\r
 @misc{Multivib,\r
 author={MongoSukulu},\r
 title={Les multivibrateurs},\r
@@ -24,6 +16,20 @@ title={NE555},
 note={https://fr.wikipedia.org/wiki/NE555}\r
 }\r
 \r
+@book{Tocci,\r
+title={Circuits numériques : théorie et applications},\r
+author={Tocci, R.J.},\r
+isbn={9782100033645},\r
+year={1996},\r
+publisher={Dunod}\r
+}\r
+\r
+@misc{CoursLogique,\r
+title={Cours de l'université de Laval sur les circuits logiques},\r
+author={Xavier Maldague},\r
+note={http://w3.gel.ulaval.ca/~maldagx/gel10279/chap5.pdf}\r
+}\r
+\r
 @misc{Cubieboard,\r
 title={Cubieboard},\r
 note={http://cubieboard.org/}\r
@@ -40,14 +46,38 @@ title={I2C},
 note={https://fr.wikipedia.org/wiki/I2C}\r
 }\r
 \r
+@misc{CubieboardDiagram,\r
+author={Cubietech},\r
+title={Cubieboard Block Diagram},\r
+note={http://dl.cubieboard.org/hardware/cubieboard_block_diagram.pdf}\r
+}\r
+\r
+@misc{A20UserManual,\r
+author={Allwinner},\r
+title={A20 User Manual},\r
+note={https://github.com/allwinner-zh/documents/raw/master/A20/A20 user manual v1.3 20141010.pdf}\r
+}\r
+\r
+@misc{AWIPCores,\r
+author={Linux-Sunxi},\r
+title={Used IP Cores},\r
+note={http://linux-sunxi.org/Used\_IP\_cores}\r
+}\r
+\r
 @misc{WikipediaAutomateFini,\r
 author={Wikipédia},\r
 title={Automate fini},\r
-note={https://fr.wikipedia.org/wiki/Automate_fini}\r
+note={https://fr.wikipedia.org/wiki/Automate\_fini}\r
 }\r
 \r
 @misc{AVRDatasheet,\r
 author={Atmel},\r
 title={Atmel 8-bit microcontroller with 4/8/16/32 kbytes in-system programmable flash datasheet},\r
-note={http://www.atmel.com/images/Atmel-8271-8-bit-AVR-Microcontroller-ATmega48A-48PA-88A-88PA-168A-168PA-328-328P_datasheet_Complete.pdf}\r
+note={http://www.atmel.com/images/Atmel-8271-8-bit-AVR-Microcontroller-ATmega48A-48PA-88A-88PA-168A-168PA-328-328P\_datasheet\_Complete.pdf}\r
+}\r
+\r
+@misc{pthread,\r
+author={Xavier Leroy},\r
+title={pthread man page},\r
+note={http://manpages.ubuntu.com/manpages/hardy/man3/pthread\_mutex\_lock.3.html}\r
 }\r
diff --git a/images/ardui2c.jpg b/images/ardui2c.jpg
new file mode 100644 (file)
index 0000000..f6779aa
Binary files /dev/null and b/images/ardui2c.jpg differ
diff --git a/images/chronogramme-multivibrateur.png b/images/chronogramme-multivibrateur.png
new file mode 100644 (file)
index 0000000..610f72c
Binary files /dev/null and b/images/chronogramme-multivibrateur.png differ
diff --git a/images/compteur-experimental.jpg b/images/compteur-experimental.jpg
new file mode 100644 (file)
index 0000000..807426b
Binary files /dev/null and b/images/compteur-experimental.jpg differ
diff --git a/images/compteur-final.jpg b/images/compteur-final.jpg
new file mode 100644 (file)
index 0000000..8d56337
Binary files /dev/null and b/images/compteur-final.jpg differ
diff --git a/images/encodage-1.png b/images/encodage-1.png
new file mode 100644 (file)
index 0000000..b78e3ff
Binary files /dev/null and b/images/encodage-1.png differ
diff --git a/images/encodage-2.png b/images/encodage-2.png
new file mode 100644 (file)
index 0000000..20befde
Binary files /dev/null and b/images/encodage-2.png differ
diff --git a/images/encodage-8.png b/images/encodage-8.png
new file mode 100644 (file)
index 0000000..57de9a5
Binary files /dev/null and b/images/encodage-8.png differ
diff --git a/images/multivibrateur.jpg b/images/multivibrateur.jpg
new file mode 100644 (file)
index 0000000..024f353
Binary files /dev/null and b/images/multivibrateur.jpg differ
diff --git a/images/schmitt.jpg b/images/schmitt.jpg
deleted file mode 100644 (file)
index 9361a37..0000000
Binary files a/images/schmitt.jpg and /dev/null differ
diff --git a/images/systeme-alarme-photo.png b/images/systeme-alarme-photo.png
new file mode 100644 (file)
index 0000000..d4e6a4e
Binary files /dev/null and b/images/systeme-alarme-photo.png differ
diff --git a/images/systeme-led-photo.png b/images/systeme-led-photo.png
new file mode 100644 (file)
index 0000000..f328060
Binary files /dev/null and b/images/systeme-led-photo.png differ
index e0c527a..c4df8a0 100644 (file)
--- a/main.tex
+++ b/main.tex
@@ -24,7 +24,7 @@
 \newcommand{\microf}{$\mathrm{\mu}$F}
 \newcommand{\iic}{$\mathrm{I^2C}$}
 \newcommand{\citenote}[1]{\footnote{\label{#1-\thepage}Référence bibliographique \cite{#1}}}
-\newcommand{\cinenoteagain}[1]{\footnotemark[\getrefnumber{#1-\thepage}]}
+\newcommand{\citenoteagain}[1]{\footnotemark[\getrefnumber{#1-\thepage}]}
 \newcommand{\citenotepage}[2]{\footnote{\label{#1-#2-\thepage}Référence bibliographique \cite{#1} page #2}}
 \newcommand{\citenotepageagain}[2]{\footnotemark[\getrefnumber{#1-#2-\thepage}]}
 \newcommand{\toldat}[1]{\footnote{\label{#1-\thepage}Cette notion sera détaillée dans la partie \ref{#1} en page \pageref{#1}.}}
index c05dfc7..9de485c 100644 (file)
@@ -433,7 +433,7 @@ Les tensions $u_1$ et $u_2$ sont donc des fonctions périodiques. La sortie qui
 \end{center}
 \end{minipage}
 \hspace{5ex}
-\end{figure}\\
+\end{figure}
 
 On observe que le signal n'est pas vraiment carré, c'est pour s'en approcher au mieux qu'on a fait la seconde hypothèse\footnote{Voir page \pageref{mv_hypotheses}.}. Le fait que $R_4 \ll R_2$\footnote{Les résistances $R_2$ et $R_3$ doivent de toute façon être élevées afin de protéger les bases des transistors d'une intensité trop importante qui les détruirait.} permet d'obtenir un temps caractéristique $\tau_2$ négligeable devant $T_1$. Cela se traduit par une charge très rapide du condensateur, dès lors que $Q_1$ devient passant, et donc $u_B$ atteint très rapidement sa valeur maximale $V_+$. Le signal périodique carré idéal créé par ce multivibrateur est présenté sur la figure \ref{mv_signal_carre}.\\
 
@@ -451,23 +451,17 @@ Nous avons réalisé le montage de ce multivibrateur avec les paramètres suivan
        \item[--] $R_1=R_4=100$ \ohm
        \item[--] $R_2=R_3=5.4$ k\ohm
        \item[--] $C_1=C_2=120$ \microf
-\end{itemize}\\
+\end{itemize}
 
 Ce qui nous amène à une période théorique de $T\approx 1$ s, c'est-à-dire que notre signal a une fréquence théorique de $1$ Hz.\\
 
-\begin{figure}[!h]
-\includegraphics[width=\columnwidth]{filename}
-\caption{Multivibrateur astable monté sur une platine d'expérimentation}
-\label{mv_photo}
-\end{figure}\\
-
-Dans un premier temps nous nous sommes servis de LEDs en sortie de façon à observer un clignotement régulier à la fréquence souhaitée. Par la suite, à l'aide d'un analyseur logique nous avons pu obtenir un chronogramme du signal carré (visible sur la figure \ref{mv_chrono}). L'analyseur logique permet de relever des tensions \og tout ou rien\fg{} en n'importe quel point du circuit, c'est-à-dire qu'il mesure l'état logique\footnote{Le concept d'état logique est détaillée dans la partie \ref{systemes-logiques}.} d'un point du circuit à tout instant (la fréquence d'échantillonnage\footnote{Il s'agit de la fréquence avec laquelle l'état logique de chaque point du circuit est relevé.} pouvant être très élevée), c'est pour cette raison qu'il est très utilisé en électronique numérique.\\
+Dans un premier temps nous nous sommes servis de LEDs en sortie de façon à observer un clignotement régulier à la fréquence souhaitée. Par la suite, à l'aide d'un analyseur logique nous avons pu obtenir un chronogramme du signal carré (visible sur la figure \ref{mv_chrono}). L'analyseur logique permet de relever des tensions \og tout ou rien\fg{} en n'importe quel point du circuit, c'est-à-dire qu'il relève l'état logique\footnote{Le concept d'état logique est détaillée dans la partie \ref{systemes-logiques}.} d'un point du circuit à tout instant (la fréquence d'échantillonnage\footnote{Il s'agit de la fréquence avec laquelle l'état logique de chaque point du circuit est relevé.} pouvant être très élevée), c'est pour cette raison qu'il est très utilisé en électronique numérique. Une photographie du montage complet est reportée en annexe \ref{mv_photo}\\
 
 \begin{figure}[!h]
-\includegraphics[width=\columnwidth]{filename}
+\includegraphics[width=\columnwidth]{chronogramme-multivibrateur.png}
 \caption{Chronogramme de la tension de sortie $u_B$ : signal périodique carré}
 \label{mv_chrono}
-\end{figure}\\
+\end{figure}
 
 On a pu observer sur ce chronogramme que le signal de sortie était tel que souhaité : périodique carré de rapport cyclique $\frac{1}{2}$. Cependant la valeur expérimentale de la période est différente de la théorique, il y a un facteur d'environ $\frac{2}{3}$ entre les deux valeurs. En essayant avec différentes valeurs de résistances et condensateurs on a pu observer une différence similaire avec les attentes théoriques.
 
@@ -476,7 +470,7 @@ On a pu observer sur ce chronogramme que le signal de sortie était tel que souh
 \newpage
 \subsection{Exemple d'utilisation dans un système réel}
 
-L'oscillateur Pierce, qui fonctionne avec un quartz est très fréquemment utilisé pour la génération des signaux d'horloge\toldat{section_horloge} au sein des microcontrôleurs\toldat{echanges-concepts-definitions}. En effet, on retrouve cet oscillateur plusieurs fois sur un système complet tel que la Cubieboard2, utilisé d'une part pour générer une horloge de $24$ MHz commune à plusieurs composants (entrées $OSC24MI$ et $OSC24MO$) et d'autre part pour générer l'horloge principale du composant \bsc{RTL8201}, dédié à la gestion du port Ethernet de la carte (entrées $X1$ et $X2$) :
+L'oscillateur Pierce, qui fonctionne avec un quartz est très fréquemment utilisé pour la génération des signaux d'horloge\toldat{section_horloge} au sein des microcontrôleurs\toldat{echanges-concepts-definitions}. En effet, on retrouve cet oscillateur plusieurs fois sur un système complet tel que la Cubieboard2, sous la forme d'un quartz et de deux condensateurs de résonance, la porte inverseuse faisant partie du circuit intégré, comme c'est généralement le cas. Il est utilisé d'une part pour générer une horloge de $24$ MHz commune à plusieurs composants (entrées $OSC24MI$ et $OSC24MO$) et d'autre part pour générer l'horloge principale du composant \bsc{RTL8201}, dédié à la gestion du port Ethernet de la carte (entrées $X1$ et $X2$) :
 
 \begin{figure}[!h]
 \centering
index e492830..dd6f784 100644 (file)
@@ -1,17 +1,17 @@
 \section*{Résumé}
 
-En tant qu'êtres humains, nous faisons l'expérience de temps à chaque instant.
+En notre qualité d'être Humain, nous faisons l'expérience du temps à chaque instant. La représentation de concept a été formalisé au cours de l'Histoire pour contribuer à l'organisation des sociétés. Elle s'est opérée au travers de différentes techniques, allant des effets périodiques naturels tels que le cycle du soleil ou les phases de la lune jusqu'à différents effets physiques comme la gravité ou les oscillations mécaniques. Cependant, depuis la fin des années cinquante, il a été possible de représenter le temps au travers de systèmes électroniques, utilisant les propriétés électriques de nombreux matériaux. Ce projet vise à fournir une compréhension globale du fonctionnement de ces systèmes. En particulier, il s'agit d'expliciter la génération de signaux de forme carrée à des fréquences précises. De plus, l'intégration de ces oscillateurs au sein de systèmes complets sera détaillée au travers de plusieurs expériences, mettant en valeur les utilisations au-delà de la théorie. Par l'étude d'un ordinateur de la taille d'une carte de crédit, la Cubieboard2, ce projet vise aussi à montrer comment les composants électroniques interagissent avec les composants basés sur le temps qui composant on ordinateur. De fait, certains aspects de l'interaction du temps avec les ordinateurs seront évoqués, accompagnés d'expériences illustrant la parallélisme et ses applications. Le cas de la communication entre plusieurs circuits numériques sera également abordé. Finalement, une synthèse de ces concepts et de leurs applications sera dressée, en mentionnant l'évolution et le futur proche de l'informatique basée sur le temps.
 
-\subsubsection*{Mots clefs : Temps }
+\subsubsection*{Mots clefs : Temps, électronique, numérique, logique, informatique, parallélisme}
 
 \vfill
 
 \begin{otherlanguage}{english}
 \section*{Abstract}
 
-As human beings, we experience time at every instant. For a very long time, we have been trying to understand time better and have come up with various representations of it in order to organize our societies. At first, natural periodical effects were used as a base for representing time going by: the course of the sun, the phases of the moon, the different seasons, etc. Pretty soon, mankind created various systems to represent and count time passing by, using various physical properties such as gravity and mechanical oscillators. However, since the 1950s, we have been able to represent time using electronic systems, based on electrical properties of various materials. This project aims to provide an overall understanding of how these systems work. In particular, it will put the emphasis on how electrical oscillator generate square signals at a fixed frequency, with considerations made about precision. In addition, the integration of those oscillators within full systems will be detailed through various experiments, highlighting actual uses of this theory. Throughout the study of a credit-card-sized single-board-computer, the Cubieboard2, this project also aims to show how electronic components interact with digital time-related parts that compose a full computer. Thus, some aspects of the interaction of time with computing systems will be explained, along with experiments regarding multi-thread computing and its implications. Finally, an overview the evolution of frequencies and core count in CPUs will be drawn, showing what to expect regarding time-based computing for the near future.
+As human beings, we experience time at every instant. For a very long time, we have been trying to understand time better and have come up with various representations of it in order to organize our societies. At first, natural periodical effects were used as a base for representing time going by: the course of the sun, the phases of the moon, the different seasons, etc. Pretty soon, mankind created various systems to represent and count time passing by, using various physical properties such as gravity and mechanical oscillators. However, since the 1950s, we have been able to represent time using electronic systems, based on electrical properties of various materials. This project aims to provide an overall understanding of how these systems work. In particular, it will put the emphasis on how electrical oscillator generate square signals at a fixed frequency. In addition, the integration of those oscillators within full systems will be detailed through various experiments, highlighting actual uses of this theory. Throughout the study of a credit-card-sized single-board-computer, the Cubieboard2, this project also aims to show how electronic components interact with digital time-related parts that compose a full computer. Thus, some aspects of the interaction of time with computing systems will be explained, along with experiments regarding multi-thread computing and its implications. The basis for communication between two integrated circuits will also be detailed. Finally, an overview of these different concepts and their applications will be drawn, with considerations about what to expect regarding time-based computing for the near future.
 
-\subsubsection*{Keywords: Time, electronics }
+\subsubsection*{Keywords: Time, electronics, digital, logic, computing, multi-threading}
 \end{otherlanguage}
 
 \vfill