gn8
authorPaul Kocialkowski <contact@paulk.fr>
Sat, 2 May 2015 23:24:57 +0000 (01:24 +0200)
committerPaul Kocialkowski <contact@paulk.fr>
Sat, 2 May 2015 23:25:08 +0000 (01:25 +0200)
13 files changed:
annexes.tex
applications-logiques.tex
aspects-informatique.tex
biblio.bib
images/alternateur.eps [new file with mode: 0644]
images/induction.eps [new file with mode: 0644]
images/ne555.png [new file with mode: 0644]
images/osc24.png [new file with mode: 0644]
images/quartz.png [new file with mode: 0644]
images/rtl8201.png [new file with mode: 0644]
images/schmitt.png [new file with mode: 0644]
main.tex
phenomenes-circuits-temps.tex

index 230a5c6..5b20cad 100644 (file)
@@ -56,3 +56,7 @@
 \caption{Compteur utilisant le circuit de synchronisation astucieusement (portes NAND)}
 \label{incrementation-final-nand}
 \end{figure}
+
+\chapter{}
+
+\lstinputlisting[caption=Ardui2c,label=ardui2c]{ardui2c.c}
index 7137d60..71f03cd 100644 (file)
@@ -6,12 +6,12 @@ On s'intéresse particulièrement aux interactions entre les montages électroni
 \subsection{Systèmes logiques}
 \label{section_logique} % systemes-logiques
 \label{systemes-logiques}
-Dans les systèmes électroniques logiques, l'information représentée par des grandeurs électriques prend la forme de valeurs discrètes\citenotepage{Tocci}{4}. On définit alors deux états en chaque point du circuit, correspondants à la présence de la grandeur considérée (une tension, un courant) : c'est l'état logique haut ou à son absence : l'état logique bas.\\
+Dans les systèmes électroniques logiques, l'information représentée par des grandeurs électriques prenant la forme de valeurs discrètes\citenotepage{Tocci}{4}. On définit alors deux états en chaque point du circuit, correspondants à la présence de la grandeur considérée (une tension, un courant) : c'est l'état logique haut ou à son absence : l'état logique bas.\\
 
 On parle de système analogique (par opposition à système logique) lorsque les grandeurs représentant l'information varient de manière continue (une infinité de valeurs est possible).\\
 Pourtant, il n'y a pas de différence fondamentale au point de vue électrique entre un système logique et un système analogique : c'est bien l'interprétation que l'on porte aux différents états possibles qui donne sens à l'information.\\
 
-Ainsi, dans la pratique, on définit un état logique en un point à partir de la tension mesurée en ce point (par rapport à la masse, le 0V du générateur). On considère la plupart du temps que les tensions d'alimentation sont de l'ordre de 5V. Ainsi, on attribue l'état bas à un intervalle de tensions proche de 0V (généralement, de 0V à 0,8V) et l'état haut à une autre intervalle, proche de 5V (généralement de 2V à 5V). L'intervalle de tensions entre 0,8V et 2V ne représente donc pas d'état logique défini.\\
+Ainsi, dans la pratique, on définit un état logique en un point à partir de la tension mesurée en ce point (par rapport à la masse, le 0V du générateur). Les tensions correspondantes à chaque état logique sont spécifiques à la technologie des composants utilisés, il en existe plusieurs sortes et les deux plus répandues sont le TTL\footnote{Transistor-Transistor Logic en Anglais, soit logique transistor-transistor en français}, qui utilise des transistors bipolaires et le CMOS\footnote{Complementary Metal Oxide Semiconductor en Anglais, soit Semi-conducteur à complémentarité métal-oxide en Français}, qui utilise des transistors à effet de champ. Pour la technologie TTL, les tensions d'alimentation sont de l'ordre de 5V. Ainsi, on attribue l'état bas à un intervalle de tensions proche de 0V ( de 0V à 0,8V) et l'état haut à une autre intervalle, proche de 5V (de 2V à 5V). L'intervalle de tensions entre 0,8V et 2V ne représente donc pas d'état logique défini.\\
 
 Cette représentation dite logique de l'information présente de nombreuses applications. En effet, elle permet tout d'abord de représenter des nombres sous la forme de quantités discrètes : on parle alors de bits\citenotepage{Tocci}{10}. Un bit représente l'unité fondamentale d'un système de numération ne pouvant prendre que deux valeurs possibles (les états logiques haut et bas), c'est à dire de la base 2. Afin de représenter des nombres plus grands que 1 (le nombre maximal représentable sur un bit), on forme des ensembles de bits (de la même manière que l'on forme des ensembles de chiffres allant de 0 à 9 pour représenter un nombre supérieur à 9 en base 10). Chaque bit porte un poids, c'est à dire qu'il représente une puissance de 2 plus ou moins élevée. Par exemple, dans la notation (101) en base 2, le bit de droite porte un poids 0 (il représente l'unité), le bit du milieu un poids 1 (il représente $2^1$) et le bit de gauche un poids 2 ($2^2$). On lit alors la valeur numérique en base 10 : $1 \cdot 1 + 0 \cdot 2^1 + 1 \cdot 2^2 = 5$. Un ensemble de 8 bits est appelé un octet, ou byte en anglais.\\
 Cette représentation se révèle particulièrement efficace pour effectuer des opération sur ces nombres ou simplement les représenter : on peut aisément associer à chaque point du circuit représentant un bit, une LED dont l'état (allumé ou éteint) traduit directement l'état logique du bit (haut ou bas).
@@ -113,7 +113,7 @@ Les portes logiques sont schématisées de manière standard par les symboles su
 \end{figure}
 
 \subsection{Bascules}
-
+\label{bascules}
 Dans les applications les plus simples de logique combinatoire, les sorties sont directement fonctions des entrées et on peut formaliser ce lien par des équations booléennes, qui traduisent les opérations effectuées. Ainsi, quand on ne met pas en jeu de rétroaction d'une sortie sur une entrée, on ne peut pas prendre en compte l'état précédent du système. Il n'est donc pas possible pour le circuit de mémoriser cet état précédent. Pourtant, de nombreuses applications dépendent de la connaissance de l'état précédent du système (par exemple dans un compteur, pour incrémenter un ensemble de bits, il faut avant tout mémoriser le décompte actuel).\\
 
 Différents montages d'électronique numérique permettent de jouer le rôle de mémoire. Plus précisément, il s'agit de circuits permettant de préserver un état après que la cause qui le produit se soit dissipée. Généralement, on cherchera également à pouvoir effacer cet état ou à le mettre à jour. Les composants les plus fondamentaux et les plus simples permettant de mémoriser un état logique sont les bascules. Il s'agit de portes logiques couplées et reliées entre-elles une certaine rétroaction de la sortie sur l'entrée. Dès lors, on ne peut plus formaliser le comportement de la bascule à partir d'une équation booléenne, mais on pourra préciser l'action de certains états appliqués en certains points du circuit.\\
@@ -177,7 +177,7 @@ Il existe d'autres types de bascules, faisant office de mémoire du circuit et d
 \label{h-\thepage}
 Dans un cadre plus général que les bascules, il existe deux grandes familles de circuits logiques : les circuits synchrones et les circuits asynchrones. Les circuit asynchrones sont les plus immédiats à la compréhension : en effet, il s'agit de circuits dans lesquels une variation d'un état d'entrée entraîne immédiatement (aux temps de propagation du signal et de réaction des composants près) un variation des sorties en conséquence (ce-qui n'exclut pas non-plus l'utilisation de rétroactions et de dispositifs de mémoire). De fait, l'état du circuit peut potentiellement changer à tout moment, ce-qui rend le système complexe à concevoir et à dépanner\citenotepage{Tocci}{167}. De plus, la communication entre deux circuits asynchrones peut s'avérer particulièrement ardue dès lors qu'il s'agit de transférer des informations numériques en série ou en parallèle, comme détaillé dans la partie \ref{synchronisation-echange-donnees}.\\
 
-Au contraire, dans les circuits asynchrones, le moment exact où un point du circuit change d'état peut être commandé par un signal externe : il s'agit d'un signal de synchronisation que l'on appelle le signal d'horloge\citenotepageagain{Tocci}{167}. Généralement, le signal d'horloge est rectangulaire, périodique et de rapport cyclique\footnote{Il s'agit du rapport entre le temps haut du signal sur une période et l'ensemble de la période.} égal à $\frac12$, tel qu'explicité dans la partie \ref{FIXME}.\\
+Au contraire, dans les circuits asynchrones, le moment exact où un point du circuit change d'état peut être commandé par un signal externe : il s'agit d'un signal de synchronisation que l'on appelle le signal d'horloge\citenotepageagain{Tocci}{167}. Généralement, le signal d'horloge est rectangulaire, périodique et de rapport cyclique\footnote{Il s'agit du rapport entre le temps haut du signal sur une période et l'ensemble de la période.} égal à $\frac12$.\\
 
 Dans la plupart des cas, on synchronisera les états logiques du circuit sur un front de l'horloge, c'est à dire au moment où le signal d'horloge passe d'un état bas à un état haut (front montant) ou d'un état haut à un état bas (front descendant) : on parle alors de synchronisation sur front. Il est également possible de synchroniser l'état sur un niveau logique (haut ou bas) et d'interdire les changements pendant cet état logique : on parle alors de synchronisation sur niveau. Selon le système en question et son utilisation, on cherchera à exploiter l'un de ces mécanismes de synchronisation, ou une combinaison habile de plusieurs d'entre eux, afin de donner cohérence au système et de faciliter l'opération recherchée.\\
 
@@ -238,7 +238,7 @@ On utilise deux bascules RS asynchrones, simples à réaliser et au fonctionneme
 
 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.
 
-\subsubsection*{Expérience}
+\subsubsection*{Expérimentation}
 
 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}.\\
@@ -247,6 +247,8 @@ Dans un premier temps, le circuit a été mis en œuvre en réalisant les portes
 
 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.\\
 
+\subsubsection*{Suppression des rebonds mécaniques}
+
 Afin de supprimer ces rebonds électriques, on met en place un système à base de condensateur et de transistor. Il s'agit d'exploiter le temps de décharge du condensateur, que l'on choisira supérieur à la durée des rebonds, relevés de l'ordre de la milliseconde au maximum (avec l'analyseur logique). On utilise un transistor avec l'émetteur porté à la masse et une résistance de valeur faible ($500$ \ohm) entre le collecteur et la tension positive ($5$ V). On considère que le circuit utilisant l'horloge dispose d'une résistance très grande devant cette valeur de résistance faible (le circuit est réalisé pour satisfaire à cette condition). De fait, dès lors que que le transistor est bloqué, le signal de sortie correspond à peu-près aux $5$ V, soit un état logique haut. Au contraire, dès que le transistor est saturé, le collecteur est porté à la masse à travers l'émetteur (on néglige la tension de la jonction collecteur-émetteur).
 \begin{itemize}
 \item[--] À la mise sous tension (quand le bouton n'est pas pressé), le condensateur se charge au travers des résistances $R1$ et $R3$ : c'est un circuit RC avec $R = R1 + R3 = 8$ k\ohm.\\
@@ -259,6 +261,8 @@ Le condensateur se charge jusqu'à ce-que la tension entre la base du transistor
 
 C'est donc le fait que le temps caractéristiques de charge ($\tau_C$) est grand devant le temps de décharge ($\tau_D$), mais également devant la durée des rebonds, que l'on évite les rebonds. Avec le dispositif anti-rebond en place, on peut constater que le système fonctionne correctement, comme en atteste le chronogramme \ref{chronogramme-compteur-fonctionne}.\\
 
+\subsubsection*{Montage autonome}
+
 Une fois le multivibrateur astable à transistors réalisé, il a été possible de le relier au circuit de décompte, qui a pu fonctionner de manière autonome. Par ailleurs, on remarque que l'état de départ du système compteur n'est pas défini à priori même s'il n'est pas instable. Cet état de départ dépend donc de l'architecture interne des composants et dans le cas de notre montage, on trouve un état de départ bas.
 \subsection{Composants actuels, état de l'art et évolution des montages}
 \label{composants-actuels}
@@ -275,37 +279,40 @@ Ainsi, on pourra réaliser simplement un compteur sur $n$ bits en utilisant $n$
 
 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 4 fois (pour $4$ bits) en utilisant des portes NON-ET, qui sont disponibles en grande quantité et à faible coût (le composant 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é).
 
 \section{Système complet modulable}
 
-Une fois le compteur réalisé pour $n$ bits, on peut l'associer à différents composants en entrée et en sortie : l'entrée est le signal d'horloge et la sortie l'ensemble des bits constituant le nombre courant du décompte. On peut alors constituer des modules de génération d'horloge en entrée ou différentes modules qui exploitent le décompte en sortie. Ainsi, selon le système que l'on cherche à réaliser, on trouvera différents modules d'entrée et de sortie correspondants. On dresse une liste de quelques exemples de systèmes complets qui ont un rapport direct au temps et des modules en question :\\
+Une fois le compteur réalisé pour $n$ bits, on peut l'associer à différents composants en entrée et en sortie : l'entrée est le signal d'horloge et la sortie l'ensemble des bits constituant le nombre courant du décompte. On peut alors constituer des modules de génération d'horloge en entrée ou différentes modules qui exploitent le décompte en sortie. Ainsi, selon le système que l'on cherche à réaliser, on trouvera différents modules d'entrée et de sortie correspondants. On dresse une liste de quelques exemples de systèmes complets qui sont des applications directes du décompte du temps, et on explicite les modules d'entrée et de sortie du compteur :\\
 
 Système d'affichage du décompte des secondes en représentation binaire :
 \begin{itemize}
-\item[--] Module d'entrée : multivibrateur de période correspondante à $1$ seconde, soit une fréquence de $1$ Hz
+\item[--] Module d'entrée : multivibrateur de période correspondante à $1$ seconde, soit une fréquence de $1$ Hz, avec interrupteur pour le départ
 \item[--] Nombre de bits : $n$ bits pour un décompte jusqu'à $2^n - 1$ secondes.
 \item[--] Module de sortie : ensemble de LEDs qui représentent le décompte au format binaire\\
 \end{itemize}
 
 \indent Système d'affichage du décompte des secondes en représentation décimale :
 \begin{itemize}
-\item[--] Module d'entrée : multivibrateur de période correspondante à $1$ seconde, soit une fréquence de $1$ Hz
+\item[--] Module d'entrée : multivibrateur de période correspondante à $1$ seconde, soit une fréquence de $1$ Hz, avec interrupteur pour le départ
 \item[--] Nombre de bits : $n$ bits pour un décompte jusqu'à $2^n - 1$ secondes.
 \item[--] Module de sortie : ensemble d'afficheurs sept-segments\footnote{Les afficheurs sept-segments permettent d'afficher tous les chiffres décimaux.} avec circuits de commande pour les afficheurs. Pour $n$ bits, on cherche le plus petit $k$ tel que $10^k \geq 2^n - 1$ : k représente alors le nombre d'afficheurs nécessaires.\\
 \end{itemize}
 
-\indent Système alarme pour la cuisson d'un œuf dur avec rappel lumineux toutes les minutes
+\indent Système alarme pour la cuisson d'un œuf à la coque avec rappel clignotant de période $30$ secondes
 \begin{itemize}
-\item[--] Module d'entrée : multivibrateur de période correspondante à $30$ secondes, soit une fréquence de $\frac1{30}$ Hz
-\item[--] Nombre de bits : on veut un décompte de $10$ minutes, soit jusqu'à $20 \cdot 30$ secondes, donc une valeur jusqu'à 20 et on a l'encadrement : $2^5 - 1 = 31 > 20 > 2^4 - 1 = 15$ donc $5$ bits.
-\item[--] Module de sortie : LED pour le rappel toutes les minutes (déclenchée avec le bit $D_0$) et bipeur piézo-électrique\footnote{Il s'agit d'un composant pouvant-être utilisé simplement pour émettre un son strident, souvent utilisé dans les alarmes.} pour l'alarme déclenché après un comparateur des $5$ bits avec la valeur binaire qui correspond aux dix minutes sur la base de $30$ secondes : $20$ en base 10 et $10100$ en base 2.\\
+\item[--] Module d'entrée : multivibrateur de période correspondante à $30$ secondes, soit une fréquence de $\frac1{30}$ Hz, avec interrupteur pour le départ
+\item[--] Nombre de bits : on veut un décompte de $3$ minutes, soit jusqu'à $6 \cdot 30$ secondes, donc une valeur jusqu'à 6 et on a l'encadrement : $2^3 - 1 = 7 > 6 > 2^2 - 1 = 3$ donc $3$ bits.
+\item[--] Module de sortie : LED pour le rappel toutes les minutes, bipeur piézo-électrique\footnote{Il s'agit d'un composant pouvant-être utilisé simplement pour émettre un son strident, souvent utilisé dans les alarmes.} quand les $3$ minutes sont écoulées et bouton poussoir pour stopper la sonnerie et redémarrer le décompte.\\
 \end{itemize}
 
-On cherchera à réaliser le premier et le dernier montage pour illustrer ces différents types de montages. On réalise les horloges avec des composants NE555 et des valeurs des composants périphériques pour obtenir les fréquences désirées, d'après les formules\citenote{WikipediaNE555Astable} :
-$$f = \frac {1.44} { (R_a + 2R_b)C }\quad~\quad \alpha = 1 - \frac {R_b} { (R_a + 2R_b) }$$
-Où $\alpha$ représente le rapport cyclique du signal (rapport du temps haut du signal sur un cycle et de la période), que l'on cherchera égal à $\frac12$\\
+On cherchera à réaliser la première et la dernière proposition pour concrétiser ces montages de décompte du temps. On réalise les horloges avec des composants NE555 et des valeurs des composants périphériques pour obtenir les fréquences désirées, d'après les formules énoncées dans la partie \ref{signal-carre-montages} en page \pageref\{signal-carre-montages}. En particulier, il sera souhaitable d'obtenir un rapport cyclique $\alpha$ égal à $\frac12$ (par exemple pour obtenir des clignotements de LEDs équilibrés). Si on prend une valeur de $R2$ faible devant $R1$ (on souhaitera une valeur au moins 100 fois plus faible, par exemple), $R2$ est négligeable devant $R1$, et deux fois plus négligeable devant $2R1$ et donc :
+$$\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é très simplement. On obtient une fréquence d'environ $1$Hz avec les valeurs des composants 
+Le premier montage est réalisé très simplement. On obtient une fréquence d'environ $1$Hz avec les valeurs des composants suivantes :
 
 Pour le dernier montage, on cherchera plutôt à faire cuire un œuf à la coque (en $3$ minutes), toujours avec une base de temps de 30 secondes, de sorte à n'avoir besoin que d'un décompte jusqu'à $6$ que l'on peut obtenir avec $3$ bits. Le rappel lumineux sera émis toutes les $30$ secondes avec un durée de $15$ secondes (une demi-période de l'horloge) aura une durée de $30$ secondes
+
+insister sur VH et que quand la bascule a ~Q = 1 et bah le compteur y tourne et que quand c'est pas le cas que le compteur il tourne pas
+le potard c'est pour le volume (genre ça régule le courant)
index 830e5eb..9a6f607 100644 (file)
@@ -3,14 +3,16 @@
 Dans cette partie, on s'intéresse tout particulièrement au rapport au temps dans les systèmes informatiques. En effet, le temps intervient dans de nombreux aspects liés à l'informatique. On distinguera deux grands types de considérations relatives au temps : d'une part les rapports liées au matériel, de l'ordre de l'électronique numérique et d'une autre part les considérations en rapport avec l'implémentation des algorithmes et leur efficacité, directement en lien avec la continuelle augmentation des performances de calcul des ordinateurs. On réalisera également plusieurs expériences pour expliciter ces rapports et problématiques, qui pourront se concrétiser par la réalisation de programmes informatiques.
 
 \section{Synchronisation des échanges de données}
+\label{synchronisation-echange-donnees}
 
 Il s'agit d'expliciter les procédés par lesquels deux systèmes informatiques physiquement distincts peuvent échanger des données (au format numérique). En particulier, on s'intéressera aux problématiques des synchronisation des données lors de ces échanges.
 
-\label{synchronisation-echange-donnees}
 \subsection{Concepts et définitions}
-On considère deux systèmes informatiques physiquement distincts : on parle de puces ou de circuits intégrés. Il s'agit fondamentalement de circuits logiques. On distinguera les circuits intégrés dont le mode de fonctionnement est unique, on parle alors d'ASIC\footnote{Application-specific integrated circuit en Anglais, soit circuit intégré propre à une application en Français.}, des circuits que l'on peut programmer au travers d'un jeu instructions qui correspondent à diverses opérations offertes par le circuit, on parle alors de microprocesseur\footnote{On distingue le microprocesseur du processeur (plus générique) : le microprocesseur est un processeur construit en un seul circuit intégré.}. C'est la composition d'un microprocesseur avec un certain nombre d'éléments externes tels que différents types de mémoire, diverses entrées-sorties, des circuits de contrôle de l'alimentation électrique, etc, que l'on appellera un ordinateur. Quand la plupart des éléments essentiels d'un ordinateurs est rassemblée en un seul circuit inrégré, on parle alors de microcontrôleur.\\
+\label{echanges-concepts-definitions}
 
-De la même façon qu'il est nécessaire de synchroniser certains types de circuits logiques (en particulier lorsque le système dépend de son état précédent), les microprocesseurs sont synchronisés avec un signal d'horloge. Par abus de language, on parlera de fréquence du microprocesseur pour parler de la fréquence l'horloge de synchronisation des opérations. En règle générale, une opération sera effectuée à chaque cycle d'horloge.\\
+On considère deux systèmes informatiques physiquement distincts : on parle de puces ou de circuits intégrés. Il s'agit fondamentalement de circuits logiques. On distinguera les circuits intégrés dont le mode de fonctionnement est unique, on parle alors d'ASIC\footnote{Application-specific integrated circuit en Anglais, soit circuit intégré propre à une application en Français.}, des circuits que l'on peut programmer au travers d'un jeu instructions qui correspondent à diverses opérations offertes par le circuit, on parle alors de microprocesseur\footnote{On distingue le microprocesseur du processeur (plus générique) : le microprocesseur est un processeur construit en un seul circuit intégré.}. C'est la composition d'un microprocesseur avec un certain nombre d'éléments externes tels que différents types de mémoire, diverses entrées-sorties, des circuits de contrôle de l'alimentation électrique, etc, que l'on appellera un ordinateur. Quand la plupart des éléments essentiels d'un ordinateurs est rassemblée en un seul circuit intégré, on parle alors de microcontrôleur.\\
+
+De la même façon qu'il est nécessaire de synchroniser certains types de circuits logiques (en particulier lorsque le système dépend de son état précédent), les microprocesseurs sont synchronisés avec un signal d'horloge. Par abus de langage, on parlera de fréquence du microprocesseur pour parler de la fréquence l'horloge de synchronisation des opérations. En règle générale, une opération sera effectuée à chaque cycle d'horloge.\\
 
 \begin{figure}[!h]
 \centering
@@ -34,31 +36,91 @@ Ces deux cartes se prètent particulièrement à l'étude de leur fonctionnement
 \item[--] Du point de vue logiciel, on peut de même étudier le fonctionnement de ces cartes avec le code source des logiciels associés, mais également modifier ce code et le redistribuer, modifé ou non, en plus de ne présenter aucune restriction formelle d'usage. On parle alors de logiciels libres.\\
 \end{itemize}
 
-De manière générale, il n'est pas garanti que ces libertés sont accordés avec un matériel quelconque. Les cartes Cubieboard2 et Arduino se prètent donc particulièrement bien à notre étude.\\
+De manière générale, il n'est pas garanti que ces libertés sont accordés avec un matériel quelconque. Les cartes Cubieboard2 et Arduino se prètent donc particulièrement bien à notre étude.
+
+\subsubsection*{Communication entre circuits intégrés}
+
+La communication entre plusieurs circuits intégrés a lieu en reliant des dispositifs d'entrée/sortie entre eux avec des conducteurs (des pistes sur un circuit imprimé ou de simples fils), que l'on pourra appeler lignes. Lorsqu'on peut relier plus que deux appareils sur les mêmes lignes, on parle alors de bus, qui désigne à la fois l'ensemble des lignes reliant les points d'entrée/sortie et de manière plus générale, l'ensemble du système de communication.\\
+Des informations vont alors être échangées au travers de ces conducteurs, le plus généralement\footnote{Certaines normes de transmision utilisent d'autres modes de communication, tels que le LVDS pour Low Voltage Differential Signaling en Anglais ou  transmission différentielle basse-tension en Français, que l'on n'abordera pas en détail.} sous forme numérique : il s'agira de bits, dont les valeurs traduisent des états logiques qui sont physiquement caractérisés par certaines tensions\footnote{Ces concepts sont détaillés dans la partie \ref{systemes-logiques}}. Le potentiel de référence utilisé pour la mesure des tensions devra donc être commun entre les deux circuits : chaque bus de données contiendra alors généralement une ligne dédié à la mise en commun de la masse.\\
+
+L'échange de données proprement dit consistera en un alternance de lectures et d'écritures sur le bus de communication. Plus précisément, un bit sera émis par un des circuits intégrés quand l'état logique est forcé par ce circuit. Il est alors nécessaire que le circuit intégré souhaitant recevoir l'information « lise » l'état logique d'une ligne, c'est à dire qu'il relève cet état logique sans l'influencer. On parlera alors d'un troisième état pour le circuit, dit état déconnecté ou de haute impédance\footnote{On parle d'impédance comme équivalent complexe de la résistance, dans le cas de variations sinusoïdales des grandeurs.} (hi-Z)\footnote{Le symbole Z représente l'impédance et le préfixe hi signifie high en Anglais, soit haut en Français}. Cet état correspondra à une forte résistance entre le point considéré et la masse, qui ne perturbe alors pas la tension appliquée en ce point par un circuit externe. Ainsi, en état hi-Z, il sera possible pour le circuit recevant l'information de relever l'état logique de la ligne sans le changer.\\
+
+Si tous les circuits reliés au bus sont en état hi-Z (c'est à dire qu'aucun circuit n'impose d'état logique), l'état du circuit sera à priori indéterminé. C'est pour cela que l'on connecte généralement aux lignes des résistances dites de rappel, de valeur faible devant la résistance interne du circuit, que l'on porte à un potentiel correspondant au niveau logique souhaité. Si on souhaite qu'une ligne du bus soit dans un état haut quand il n'y a pas d'activité, on reliera alors cette ligne avec une résistance de rappel à la tension positive de référence.
+
+\subsubsection*{Écrasement, arbitrage et rôles}
+
+Dans le cas où tous les circuits intégrés utilisent la même ligne à la fois pour la lecture et l'écriture, on peu se retrouver dans le cas où deux circuits intégrés cherchent à écrire sur la ligne simultanément : on parle alors d'écrasement des données. C'est une des raisons qui conduit à la nécessité d'attribuer des temps réservés à la lecture et à l'écriture pour chaque puce et donc de synchroniser les communications.\\
+Cependant, il est également possible de mettre en place un arbitrage : les deux circuits doivent alors lire l'état de la ligne après avoir écrit un bit. Si l'état ne correspond pas au bit envoyé, le circuit perd la main et doit cesser d'écrire sur le bus : on dit qu'il a perdu l'arbitrage. Cela n'est possible que quand un état logique a priorité sur l'autre (il s'agit d'une caractéristique du bus) : si un circuit inscrit un état haut alors qu'un autre circuit inscrit simultanément un été bas, la ligne prendre systématiquement l'un des deux états. On qualifie alors cet état de dominant et l'autre état de récessif. Par exemple, pour le bus CAN\footnote{Controller Area Network en Anglais, soit contrôleur de zone de réseau en Français}, très utilisé dans les automobiles, l'état logique bas est dominant et l'état haut est récessif.\\
+
+Plutôt que de permettre à tous les circuits intégrés d'écrire en même temps, certains bus attribuent également des rôles, maître ou esclave à chaque circuit. C'est par exemple le case du bus \iic\footnote{\iic/IIC pour Inter Integrated Circuits en Anglais, soit inter circuits intégrés en Français}, très utilisé pour la communication entre le processeur et les puces dans les ordinateurs. Généralement, le circuit dédié à la gestion de l'\iic\ attaché au processeur (on parle de contrôleur \iic) est maître du bus alors que toutes les autres puces reliées au bus sont esclaves. Dans cette configuration, seul le maître peut commencer à écrire sur le bus et les esclaves ne pourront écrire sur le bus qu'en réponse à une demande du maître.\\
+
+Quand plusieurs esclaves sont connectés au même bus, des adresses pourront leur être attribuées pour que le maître indique à quel circuit la transaction s'adresse. L'esclave pourra alors confirmer sa présence en écrivant un bit de valeur particulière à un moment donné de l'échange : on parle d'acquittement. La valeur de ce bit sera choisie en fonction du rappel de la ligne : s'il existe une résistance de rappel connectée à l'état logique haut, le bit d'acquittement sera d'état logique bas et réciproquement, de sorte que le bit ne soit jamais lu si aucun esclave n'est concerné. L'utilisation d'un bit d'acquittement pourra d'ailleurs également être utilisée pour confirmer le bon déroulement d'une action à la fois par le maître et l'esclave concerné.
+
+\subsubsection*{Protocole de communication}
+
+Il s'agit bien là de règles formelles qui doivent-être respectées par chaque puce utilisant le bus : l'ensemble de ces règles constitue le protocole de communication utilisé sur le bus. En particulier, le protocole va permettre de définir quel puce peut lire ou écrire à quel moment. Cela n'est cependant possible qu'avec un signal de synchronisation permettant de découper le temps en quantités discrètes : on utilise donc un horloge comme tel signal de synchronisation, qui fait partie intégrante du bus et qui doit être prise en compte par tous les circuits connectés au bus. Par exemple, dans le cas du bus \iic, il n'est permis de changer l'état de la ligne de données que sur un temps bas de l'horloge. Le temps haut est alors réservé à la lecture de l'état du bus (sauf exceptions telles que le signalement d'un début ou d'une fin de transaction). Le protocole définit par ailleurs la signification de la succession des bits envoyés sur le bus, à partir du signalement du début de la transaction. On détaillera en partie ce protocole dans la partie \ref{communication-i2c}.\\
+
+Certains bus n'utilisent cependant pas d'horloges de synchronisation mais une configuration explicite de la vitesse de changement d'état du bus, commune à tous les circuits reliés au bus. La communication sera synchronisée par un bit ou un ensemble de bits donnés que le circuit de réception pourra identifier. Des horloges internes aux composants seront de cette manière synchronisées entre-elles pour permettre de donner sens à la communication. Ce principe est exploité dans les composants UART\footnote{Universal Asynchronous Receiver Transmitter en Anglais, soit émetteur-récepteur asynchrone universel en Français.}.\\
+
+Il existe donc une grande variété de bus, chacun avec un certain nombre de caractéristiques :
+\begin{itemize}
+\item[--] Bus synchrone (avec une horloge partagée pour la synchronisation) ou non
+\item[--] Communication en série (une seule ligne de données permettant d'envoyer un bit à la fois) ou en parallèle (plusieurs lignes de données et donc plusieurs bits à la fois)
+\item[--] Circuits intégrés affectés d'une priorité de type maître/esclave ou non
+\item[--] Avec une ligne dédiée à la lecture de l'un des circuits (et l'écriture de l'autre) et une autre ligne réciproquement ou non
+\item[--] Avec résistance(s) de rappel à un niveau particulier
+\end{itemize}
+
+\subsection{Communication entre systèmes numériques via le protocole \iic }
+\label{communication-i2c}
+
+Au sein de la Cubieboard2, la communication avec le circuit intégré responsable de la gestion de l'alimentation électrique, le PMIC\footnote{Power Management Integrated Circuit en Anglais, soit circuit intégré de gestion de l'énergie en Français.} \bsc{AXP209} est effectuée par un bus \iic. Il s'agit d'un bus aux caractéristiques suivantes :
+\begin{itemize}
+\item[--] Synchrone, horloge de fréquence quelconque allant jusqu'à $400$ kHz
+\item[--] Communication en série
+\item[--] Circuits intégrés affectés d'une priorité de type maître/esclave (le SoC est maître) et chacun d'une adresse
+\item[--] Avec une ligne commune pour la lecture et l'écriture
+\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é en annexe \ref{axp209-i2c}.\\
+
+On souhaite alors faire communiquer la Cubieboard2 avec le microcontrôleur Arduino, en utilisant 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.\\ 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.\\
+
+\subsubsection*{\bsc{U-Boot} et prise en charge du contrôleur \iic\ $TWI1$}
+
+Du point de vue du logiciel, on utilisera directement la ligne de commande du chargeur de démarrage \bsc{U-Boot}. Il s'agit du premier logiciel exécuté par la carte (avant le chargement du système d'exploitation) et qui offre un interpréteur de commandes proposant de multiples fonctionnalités, y compris la gestion du bus \iic. Cependant, au jour de réalisation de l'expérience, \bsc{U-Boot} ne prenait en charge que le premier contrôleur \iic, noté $TWI0$ (utilisé pour communiquer avec le PMIC \bsc{AXP209}).\\
+
+Afin de réaliser l'expérience, nous avons modifié le code source (écrit en langage C) d'\bsc{U-Boot}, ce-qui a été possible comme il s'agit d'un logiciel libre. En particulier, il aura été nécessaire de mettre en place une gestion dynamique de l'index du bus à utiliser, de configurer les points d'entrée/sortie dédiés à l'\iic\ et de définir l'emplacement en mémoire de ces contrôleurs. Le développement d'\bsc{U-Boot} est conduit de manière communautaire (comme c'est souvent le cas pour un logiciel libre) et les contributions externes sont les bienvenues, ce-qui nous aura poussé à proposer notre modification aux mainteneurs du logiciel, au travers de la liste de discussion\footnote{Liste de discussion du projet \bsc{U-Boot} : http://lists.denx.de/mailman/listinfo/u-boot} prévue à cet effet. Après 5 différentes itérations de la proposition\footnote{Archives de la liste de discussion du projet \bsc{U-Boot} pour le mois d'Avril 2015 : http://lists.denx.de/pipermail/u-boot/2015-April/}, résultats des commentaires émis par la communauté et les mainteneurs des parties du code concernés par la modification, celle-ci a finalement été approuvée et intégrée au code source officiel du projet\footnote{Modification "i2c: mvtwsi: Support for up to 4 different controllers" : http://git.denx.de/?p=u-boot.git;a=commit;h=dd82242b4dd7d251ef9ba43563cf9a0017d6f98e}\footnote{Modification "sunxi: Complete i2c support for each supported platform
+" : http://git.denx.de/?p=u-boot.git;a=commit;h=6c739c5d8a3466f8ef2f8543636484957bcca6ee}. On aura vérifié le bon fonctionnement du code en utilisant l'analyseur logique et en lançant un sondage du bus avec la commande $i2c\ probe$, qui fait apparaître des signaux sur la lignes de donnée et la ligne d'horloge.
+
+\subsubsection*{Réalisation du programme}
+
+Une fois les aspects matériels et logiciels en place, on peut commencer la réalisation du programme propre à l'Arduino. Celui-ci sera réalisé en langage C natif, c'est à dire sans sur-couche propre à l'Arduino. Il existe en effet un IDE\footnote{Integrated Development Environment en Anglais, soit environnement de développement intégré en Français} propre à l'Arduino, contenant un certain nombre de sur-couches au langage C++ utilisé. Comme notre application est fortement dépendante du temps, on cherchera à écrire du code au plus proche du langage machine afin de ne pas ralentir l'exécution. Le système de compilation sera basé sur de traditionnels $Makefiles$, très couramment utilisés pour le développement au sein de systèmes de type \bsc{Unix}. Le compilateur utilisé est une variante de \bsc{GCC} propre à l'architecture matérielle \bsc{AVR} : \bsc{avr-gcc}. On utilisera une librairie C standard propre à l'\bsc{AVR}, qui fournit également des définitions propres au microcontrôleur : l'\bsc{avr-libc}. Enfin, le logiciel sera envoyé sur la carte en utilisant l'utilitaire \bsc{avrdude}. Enfin, on utilisera l'outil de gestion de code source \bsc{git} pour garder trace des modifications. Tous ces logiciels sont des logiciels libres et on donne d'ailleurs comme licence d'utilisation à notre logiciel, astucieusement nommé $ardui2c$, la Licence Publique Générale GNU en version 3 ou plus récente\footnote{Texte complet de la licence : https://www.gnu.org/licenses/gpl.html}, ce-qui en fait également un logiciel libre.\\
+
+Le code source lui-même est rédigé avec un terminologie en Anglais, afin qu'il soit techniquement compréhensible (et modifiable) par le plus grand nombre, mais on attache toute de même des commentaires en Français, afin de faciliter sa compréhension dans le cadre de notre projet. Afin d'analyser l'exécution étape par étape du programme au cours de son écriture, on cherche à utiliser un dispositif d'entrée/sortie simple à utiliser. L'Arduino dispose d'un contrôleur UART permettant d'envoyer au cours de l'exécution des informations de débogage (typiquement, des chaînes de caractères) à un ordinateur relié à la carte par USB (un convertisseur UART/USB est également intégré à la carte Arduino). Cependant, la vitesse de transmission des informations est au maximum de $115200$ bits/s (on parle de bauds), qui n'est pas suffisante pour transmettre suffisamment rapidement ces informations tout en relevant les changements des lignes du bus. En effet, une première expérience montre que le microcontrôleur n'arrive pas à correctement détecter les changements d'états de la ligne d'horloge, qui a une fréquence que l'on a fixée à $50$ kHz, soit $2 * 50 000 = 100 000$ changements d'état logique par seconde. Il est donc évident que cette solution n'est pas utilisable.\\
+
+Pour palier à ce problème, on a alors utilisé une sortie numérique du microcontrôleur que l'on dédie au débogage ($DEBUG$) et dont on inversera l'état logique à un moment donné de l'exécution du programme (par exemple à la détection d'un événement en particulier). Il s'agit de la fonction $debug$, que l'on associera à un test que l'on souhaite vérifier à l'exécution. Certains événements, tels que les conditions de départ ou de fin ont ainsi pu être détectés, mais on remarque un décalage entre la fin des événements et l'apparition du changement sur la ligne de débogage. L'optimisation du code produit lors de la compilation (argument $-Os$ du compilateur \bsc{avr-gcc}) permet de gagner en temps d'exécution (moins d'instructions à exécuter) et donc de rapprocher le changement d'état de la ligne de débogage de l'événement. On utilise encore une fois l'analyseur logique pour relever l'état des lignes $SDA$, $SCL$ et $DEBUG$.
 
-La communication entre plusieurs circuits intégrés a lieu en reliant des dispositifs d'entrée/sortie entre eux avec des conducteurs (des pistes sur un cicruit imprimé ou de simples fils). Lorsqu'on peut relier plus que deux appareils sur les mêmes conducteurs, on parle alors de bus, qui désigne à la fois l'ensemble des conducteurs reliant les points d'e/s\footnote{entrée/sortie} et de manière plus générale, l'ensemble du système de communication.\\
-Des informations vont alors être échangées au travers de ces conducteurs, le plus généralement\footnote{Certaines normes de transmision utilisent d'autres modes de communication, tels que le LVDS pour Low Voltage Differential Signaling en Anglais ou  transmission différentielle basse-tension en Français, que l'on n'abordera pas en détail.} sous forme numérique : il s'agira de bits, dont les valeurs traduisent des états logiques qui sont physiquement caractérisés par certaines tensions\footnote{Ces concepts sont détaillés dans la partie \ref{systemes-logiques}}. Le potentiel de référence utilisé pour la mesure des tensions devra donc être commun entre les deux circuits : chaque bus de données contiendra alors généralement un conducteur dédié à la mise en commun de la masse.\\
 
+C'etst à \ref{ardui2c}.
 
-\vfill
+écriture ardui2c,
++ référence wikipedia sur le protocole
++ on écrit sur les ports en mettant ou enlevant des bits (on utilise les opérations booléennes du langage C)
++ on a le droit de changer que sur le temps bas et on lit sur le temps haut, donc on vérifie l'état de l'horloge avant chaque opération et si besoin on attend l'état de la ligne nécessaire.
++ machine à états (penser à masse commenter le code comme ça pas besoin de l'expliciter dans le mémoire)
++ parler un peu des registres
 
-+ définition d'un bus
-+ ce-que ça signifie électriquement, mesure de la tenstion et application de tension (lecture/écriture)
-+ nécessaire de synchroniser (qui parle quand et à quelle vitesse)
-+ protocoles de communications (pour dire quoi et comment)
-+ exemple du protocole i2c (introduire maitre esclave) et où on s'en sert + axp209 sur la cubieboard2
-\subsection{Communication entre deux circuits intégrés via le protocole $I^2C$ }
-+ce qu'on veut faire (implémentation esclave sur l'aduino avec la cubieboard)
-+setup électrique/logiciel sur la cubieboard
-+histoire du patch u-boot machin
-+écriture ardui2c, gestion de version, machine à états (penser à masse commenter le code comme ça pas besoin de l'expliciter dans le mémoire)
-+problèmes qu'on a eu avec les vitesses USB UART, PIN debug
-+montrer le prompt u-boot où ça marche et ça renvoie cpbx et on peut modifier
++ montrer le prompt u-boot où ça marche et ça renvoie cpbx et on peut modifier
 + chronogrammes AVEC l'interprétation de l'i2c dans pulseview
 \section{Optimisation des temps d'exécution des programmes}
 \subsection{Efficacité du traitement informatique et complexité}
 * Algorithmes et complexité, efficacité rapport au temps, qu'on peut optimiser mais ça dépend toujours de la visse d'exécution
 * Pour que ce soit plus rapide, il faut augmenter la fréquence de traitement
+* c'est pareil pour les communications d'ailleurs, fréquence de l'horloge du bus
 \subsection{Limites à la montée en fréquence et parallelisme}
 * Au bout d'un moment, ça pose problème
 * Du coup on a plusieurs coeurs en même temps => parallelisme
diff --git