diff options
Diffstat (limited to 'chapters/output.rst')
| -rw-r--r-- | chapters/output.rst | 702 |
1 files changed, 702 insertions, 0 deletions
diff --git a/chapters/output.rst b/chapters/output.rst new file mode 100644 index 0000000..097cef2 --- /dev/null +++ b/chapters/output.rst @@ -0,0 +1,702 @@ +.. -*- mode: rst -*- +.. -*- coding: utf-8 -*- + +Premier programme +================= + +Faire clignoter une |led| est l'une des premières étapes avec Arduino. C'est +aussi une introduction pour comprendre le fonctionnement de la carte. + +Ce premier programme ne nécessite pas de branchement : une |led| est présente +sur la carte et devrait s'allumer automatiquement en lançant le programme. + +Décomposition du programme +-------------------------- + +L'initialisation +~~~~~~~~~~~~~~~~ + +L'initialisation s'exécute seulement au démarrage du programme sur la carte +(et sera de nouveau exécutée si l'on appuie sur le bouton `reset`). + +.. code-block:: arduino + :number-lines: 9 + + // the setup routine runs once when you press reset: + void setup() { + // initialize the digital pin as an output. + pinMode(13, OUTPUT); + } + +Une seule instruction est lancée dans cet extrait : :index:`pinMode` +`pinMode` [#]_. Celle-ci permet d'indiquer au microcontrolleur si la broche +doit être configurée pour envoyer du courant, ou en recevoir. Puisque nous +souhaitons ici allumer une |led|, nous lui passons le paramètre `OUTPUT` en +argument. + +.. [#] https://www.arduino.cc/en/Reference/pinMode + +L'exécution +~~~~~~~~~~~ + +Voici le cœur du programme, ces instructions seront exécutées en boucles, +indéfiniment, tant que la carte sera sous tension. + +.. code-block:: arduino + :number-lines: 15 + + // the loop routine runs over and over again forever: + void loop() { + // turn the LED on (HIGH is the voltage level) + digitalWrite(13, HIGH); + delay(1000); // wait for a second + digitalWrite(13, LOW); + // turn the LED off by making the voltage LOW + delay(1000); // wait for a second + } + +Ce bloc est composé de quatre instructions, qui appellent deux fonctions +différentes. :index:`digitalWrite` `digitalWrite` [#]_ permet d'envoyer ou de +couper le courant sur une broche donnée. Pour allumer la |led|, nous commençons +donc en donnant `HIGH` en paramètre. + +.. [#] https://www.arduino.cc/en/Reference/digitalWrite + +Vient ensuite une instruction permettant de faire une pause dans le programme : +:index:`delay` `delay` [#]_. Cette fonction prend en paramètre la durée de la +pause (en millisecondes, `1000` vaut donc une seconde). + +.. [#] https://www.arduino.cc/en/Reference/delay + +Afin de faire clignoter la |led|, il est nécessaire de l'éteindre ensuite. +C'est pourquoi nous retrouvons l'instruction `digitalWrite`, mais cette fois +avec la valeur `LOW`, suivi d'une nouvelle pause d'une seconde. + +.. sidebar:: digital + + digital signifie *numérique*. Le terme indique une valeur que l'on peut + exprimer en nombre entier (1, 2, 3…). + +Le programme complet +-------------------- + +.. sidebar:: Chargement + + Ce programme est disponible dans l'environnement Arduino dans les exemples : + Basic / Blink + +.. code-block:: arduino + + /* + Blink + Turns on an LED on for one second, then off for one + second, repeatedly. + + This example code is in the public domain. + */ + + // the setup routine runs once when you press reset: + void setup() { + // initialize the digital pin as an output. + pinMode(13, OUTPUT); + } + + // the loop routine runs over and over again forever: + void loop() { + // turn the LED on (HIGH is the voltage level) + digitalWrite(13, HIGH); + delay(1000); // wait for a second + digitalWrite(13, LOW); + // turn the LED off by making the voltage LOW + delay(1000); // wait for a second + } + +Utiliser une led externe +======================== + +.. sidebar:: Une led + + .. image:: content/5mm_Red_LED.jpg + :align: center + :width: 100% + +Suite à ce premier exemple, nous allons maintenant faire évoluer notre +programme pour l'adapter à une |led| que nous allons brancher à la carte. +Puisque nous intégrons un composant externe, nous allons devoir veiller à ce +que celui-ci soit compatible avec l'alimentation de la carte Arduino : certains +composants nécessitent une tension plus importante (par exemple un moteur), +d'autre des tensions plus faibles (au risque de faire griller le composant). + +Le tableau suivant indique la valeur minimale et maximale supportée par +différents types de |led|, ainsi que l'intensité du courant pour la tension +minimale et maximale. + +======= =========== ============== ================ +Taille Couleur Tension (`V`) Intensité (`mA`) +======= =========== ============== ================ +3mm rouge `1.8`-`2.5` `5`-`18` +3mm vert `2.1`-`2.6` `5`-`17.5` +3mm jaune `1.8`-`2.0` `5`-`17.5` +5mm rouge `1.9`-`2.3` `5`-`18` +5mm vert `1.9`-`2.5` `4`-`14` +5mm jaune `1.9`-`2.5` `5`-`15` +======= =========== ============== ================ + +.. sidebar:: Polarisation + + la |led| ne laisse passer le courant que dans un seul sens. C'est pourquoi + les deux broches ne sont pas de la même longueur. La patte la plus courte + doit être branchée sur le pôle `-`. + +.. admonition:: Attention + :class: warning + + La tension de sortie de la carte est de 5 |V|. Or, en lisant le tableau, on + voit bien que les |led|\ s ne supporteront pas cette tension à leur borne, il + est donc nécessaire de mettre en place un système pour réduire la tension + dans les limites de ce qui est acceptable par la |led|. + +Dans notre situation, la tension délivrée par la carte Arduino et le courant +qui traversera la |led| sont stables — la |led| ne modifie pas son comportement +pendant son fonctionnement. Nous pouvons utiliser le schéma le plus simple pour +réduire la tension : *la résistance chutrice*. + +.. figure:: content/cligo_led.pdf + :width: 100% + + Arduino, LED et une résistance + +Calcul de la résistance +----------------------- + +La résistance à placer se calcule de la manière suivante : + +.. math:: + + R = \frac{(U-Ul)}{I} + +.. sidebar:: Valeurs + + :R: Résistance + :U: Tension de l'alimentation + :Ul: Tension de la |led| + :I: Intensité de la |led| + +Dans notre exemple, en prenant l'intensité maximale supportée par la |LED| nous +obtenons le calcul suivant : + +.. math:: + + R &= \frac{(5-2.5)}{0.018} \\ + &= 139\ \Omega + +.. sidebar:: Déjà des calculs ? + + Ce petit calcul peut sembler théorique, toutefois nous en aurons besoin par + la suite, quand il sera nécessaire d'alimenter des composants avec des + tensions différentes que l'alimentation. (Nous aborderons cela plus loin avec + les notions de *Pont diviseur*, ainsi que les *régulateurs de tension*). + +La résistance choisie doit donc avoir une valeur supérieure. En consultant la +série E12 [#]_, on peut choisir la valeur la plus proche (par exemple 220 +:math:`\Omega`). + +.. [#] Série de douze valeurs utilisées dans les composants électroniques : + https://fr.wikipedia.org/wiki/CEI_60063 + +Vérification de l'intensité +--------------------------- + +On sait que : :math:`I = \frac{U}{R}` soit ici : + +.. math:: + + I &= \frac{U-Ul}{R} \\ + &= \frac{5-2.5}{220} \\ + &= 11.36\ mA + +Ce qui est suffisant pour alimenter notre composant. + + +Mise à jour du programme +------------------------ + +Nous pouvons maintenant mettre à jour notre programme. Il s'agit toujours du +même code que celui présenté plus haut avec toutefois une légère différence : +au lieu d'envoyer du courant sur la broche `13`, nous l'envoyons désormais sur +la broche `9`. Il est donc nécessaire de faire quelques modifications au lignes +`12`, `18` et `20`. + +Faire varier la luminosité +========================== + +Il existe 6 ports sur la carte Arduino permettant de faire varier la tension de +sortie : `3`, `5`, `6`, `9`, `10` et `11`. Les autres port permettent seulement +d'envoyer la tension `HIGH` ou `LOW`, c'est-à-dire 5 |V| ou 0 |V|. + +Il est possible d'utiliser la fonction :index:`analogWrite` `analogWrite` [#]_ +sur chacun de ses ports, en envoyant une valeur comprise entre `0` et `255`. + +.. [#] https://www.arduino.cc/en/Reference/AnalogWrite + +.. raw:: latex + + + \begin{center} + \begin{tikzpicture}[scale=2.6] + + \foreach \x in {0,0.5,...,5} { + \pgfmathtruncatemacro\result{\x * 255 / 5} + \draw (\x,-4pt) -- (\x,4pt) + node [below,yshift=-20] {\pgfmathprintnumber{\result}} + node [above] {$\x$V}; + } + + \draw (0,0) -- (5,0); + + \end{tikzpicture} + \end{center} + +.. sidebar:: `PWM` + + La variation de la tension est réalisée via la *modulation de largeur + d'impulsions* [#]_ qui permet de faire varier la tension en faisant varier de + manière très brève la durée pendnant laquelle le courant est émis. + +.. [#] https://fr.wikipedia.org/wiki/Modulation_de_largeur_d'impulsion + +.. note:: + + Les valeurs présentées ici sont des tensions *moyennes*. En envoyant la + valeur `127`, la tension sur la broche sera de 5 |V|, mais pendant une durée + très courte : + + .. raw:: latex + + \begin{tikzpicture} + \draw[help lines] (0,0) grid (7,1); + \draw[thick] (0,0) node[anchor=base east] {0V} -- ++(0,0) + \foreach \x in {1,...,7}{ + -- +(0,1) -- +(0.5,1) -- +(0.5,0) -- ++(1,0) + } -- +(0,.5); + \draw[thick,anchor=north east] (0,1) node {5V}; + \end{tikzpicture} + + Avec la valeur `192` la tension reste à 5 |V| pendant une durée plus longue : + + .. raw:: latex + + \begin{tikzpicture} + \draw[help lines] (0,0) grid (7,1); + \draw[thick] (0,0) node[anchor=south east] {0V} -- ++(0,0) + \foreach \x in {1,...,7}{ + -- +(0,1) -- +(0.75,1) -- +(0.75,0) -- ++(1,0) + } -- +(0,.5); + \draw[thick,anchor=north east] (0,1) node {5V}; + \end{tikzpicture} + + Dans tous les cas, la tension à la sortie de la borne sera de 5 |V|. Il est + toutefois possible de transformer ce signal en une vraie tension linéaire, à + l'aide d'un condensateur supplémentaire [#]_. + +.. [#] https://provideyourown.com/2011/analogwrite-convert-pwm-to-voltage/ + +.. admonition:: Mesure de la tension + :class: exercice + + Avec un multimètre, mesurer la tension en sortie de la borne en fonction de + diverses valeurs. + +Programme +--------- + +.. sidebar:: Ressource limitée ! + + Cette capacité à contrôler la tension de sortie est très intéressante (par + exemple pour demander à un moteur de tourner plus ou moins vite), mais est + limitée à 6 bornes seulement. Il vaut mieux les réserver quand nous avons + besoin d'une sortie analogique. + +.. code-block:: arduino + + // Fade + + // This example shows how to fade an LED on pin 9 + // using the analogWrite() function. + + // This example code is in the public domain. + + int led = 9; // the pin that the LED is attached to + int brightness = 0; // how bright the LED is + int fadeAmount = 5; // how many points to fade the LED by + + // the setup routine runs once when you press reset: + void setup() { + // declare pin 9 to be an output: + pinMode(led, OUTPUT); + } + + // the loop routine runs over and over again forever: + void loop() { + // set the brightness of pin 9: + analogWrite(led, brightness); + + // change the brightness for next time through the loop: + brightness = brightness + fadeAmount; + + // reverse the direction of the fading + // at the ends of the fade: + if (brightness == 0 || brightness == 255) { + fadeAmount = -fadeAmount ; + } + // wait for 30 milliseconds to see the dimming effect + delay(30); + } + + +Générer du son +============== + +.. sidebar:: Un piezzo buzzer + + .. image:: content/piezzo_buzzer.jpg + :align: center + :width: 100% + +Avec un piezzo buzzer il est possible d'ajouter une sortie sonore au programme. +Ceux que l'on trouve dans le commerce supportent une tension allant de 3 à +24 |V|, ce qui permet de brancher le buzzer directement en sortie de la carte. + +Le composant permet de produire du son en fonction de la fréquence du signal de +sortie. + +Il est possible d'utiliser la fonction `digitalWrite` sur une borne pour +produire un beep, mais il est plus intéressant de pouvoir contrôler la +fréquence de sortie. Nous utiliserons pour cela la fonction :index:`tone` +`tone` [#]_. (Cette instruction peut être utilisée sur une sortie numérique, il +n'est donc pas nécessaire de réserver une sortie analogique pour le buzzer.) + +.. [#] https://www.arduino.cc/en/Reference/Tone + +.. sidebar:: Qualité du son + + La fonction `tone` ne sait produire qu'un signal carré, ce qui signifie que + le son n'aura jamais les harmoniques d'un fichier :smallcaps:`mp3` ou + :smallcaps:`wav`. + +.. note:: + + La fonction `tone` n'est pas disponible sur toutes les cartes Arduino. Si + vous utilisez une carte *Gemma* ou *Due* (ou un autre microcontrolleur), la + fonction ne sera pas disponible. + + Dans ce cas, il est possible d'écrire soit même la fonction en utilisant + les instructions `delayMicroseconds` et `digitalWrite`. Dans ce cas la + fréquence des sons ne sera pas garantie, mais le but n'est pas de faire de la + carte Arduino un outil `hi-fi` : + + .. code-block:: arduino + + void tone(int targetPin, long frequency, long length) { + // calculate the delay value between transitions + // 1 second's worth of microseconds, divided by the + // frequency, then split in half since there are two + // phases to each cycle + long delayValue = 1000000/frequency/2; + // calculate the number of cycles for proper timing + // multiply frequency, which is really cycles per + // second, by the number of seconds to get the + // total number of cycles to produce + long numCycles = frequency * length/ 1000; + for (long i=0; i < numCycles; i++) { + // write the buzzer pin high to push out the diaphram + digitalWrite(targetPin,HIGH); + // wait for the calculated delay value + delayMicroseconds(delayValue); + // write the buzzer pin low to pull back the diaphram + digitalWrite(targetPin,LOW); + // wait again or the calculated delay value + delayMicroseconds(delayValue); + } + } + +Par exemple, en connectant le buzzer sur la broche `8`, l'instruction suivante +permettra de jouer un *la* pendant une seconde : + +.. code-block:: arduino + + tone(8, 440, 1000); + +En faisant varier la fréquence ainsi que la durée de chaque note, nous pourrons +ainsi jouer des mélodies (simples). Il est par contre nécessaire de connaître +la fréquence de la note que l'on souhaite jouer. (La table peut être obtenue +facilement sur internet [#]_). + +.. [#] https://fr.wikipedia.org/wiki/Note_de_musique + +.. sidebar:: Codification des notes + + En anglais, chaque note est codée par une lettre de A à G : C pour Do, D pour + Ré, F pour Mi, etc. + +Plutôt que d'écrire directement les fréquence dans le programme, il est plus +simple de coder les notes, et laisser l'application jouer les notes +correspondantes ; la notation anglaise est souvent utilisée. En associant +chaque fréquence à une valeur dans le programme, il devient plus facile +d'écrire la mélodie qui peut être codée en écrivant directement les notes de +musiques ! + +.. admonition:: Exercice + :class: exercice + + Écrire une petite mélodie ! + +Contrôler un moteur +=================== + +Avec ces instructions, il est temps de passer aux choses sérieuses. En +contrôlant les sorties à l'aide de l'instruction `digitalWrite`, nous allons +pouvoir donner du mouvement au robot en lui donant des roues. Mettre en route +un moteur n'est pas difficile, mais nécessite de prendre certaines précautions +avant de connecter notre moteur. + +.. admonition:: Attention + :class: warning + + Ne jamais brancher un moteur directement à la carte Arduino. D'une part parce + que la tension nécessaire pour activer le moteur risque d'être trop + importante pour la carte (dans le meilleur des cas, le moteur ne tournera + pas, dans le pire des cas la carte grillera), mais aussi parce qu'un moteur + fonctionne de la même manière qu'une dynamo : il produit du courant quand il + tourne. Ce courant risque de remonter dans la carte et générer un + court-circuit. + +Pour cette raison, nous utiliserons un contrôleur externe, destiné à nous +éviter de nombreuses complications : le L293D [#]_. Cette puce va nous permettre : + +.. [#] http://www.ti.com/lit/ds/symlink/l293d.pdf [#]_ + +.. [#] Prenez le temps de lire les spécification des composants. Elles sont en + anglais, mais donnent toutes les informations nécessaire pour utiliser + le composant au mieux : les caractéristiques générale, mais également + les cas d'utilisation, les valeurs maximales supportées, les conseils + de branchement etc. + +.. sidebar:: Une puce L293D + + .. image:: content/L293D_Motor_Driver.jpg + :align: center + :width: 100% + +- de protéger la carte Arduino en empêchant les surtensions : il intègre des + diodes de protections et des contrôleurs thermiques pour protéger le circuit. +- de limiter le cablage et les composants à utiliser : le composant supporte + des tensions de fonctionnement allant de 4,5 à 36 |V|, et permettra donc de + délivrer des tensions beaucoup plus puissantes que ce que peut fournir la + carte Arduino. + +.. note:: + + Il est parfaitement possible de contrôler un moteur directement à partir de + la carte Arduino sans utiler ce type de composant, mais nous compliquons + alors le schéma de cablage inutilement. La documentation technique du + composant nous montre comment réaliser le cablage équivalent avec des diodes + et des transitors (un double pont en H). + +En fait, la puce ne permet pas simplement de contrôler un moteur, mais quatre +! (ou alors deux moteurs pouvant tourner dans les deux sens). Cela correspond à +notre robot qui aura deux roues motrices : une seule puce et quelques fils +pourront permettre de faire rouler notre robot et lui faire réaliser quelques +manœuvres. + +.. figure:: content/l293d.pdf + :width: 50% + + L293D + + :EN: Puissance du moteur : permet de contrôler la vitesse de rotation du + moteur en fonction de la tension appliquée à la borne. Cette borne + peut être reliée à une borne analogique de la carte Arduino. + :A: Activation du moteur : permet d'activer le moteur connecté. Ces + bornes sont à relier aux sorties digitales de la carte. + :Y: Sortie à relier aux bornes des moteurs. + :VCC2: Alimentation des moteurs : cette borne est à relier à + l'alimentation générale (36 |V| max.) + :VCC1: Alimentation du composant (5 |V|) : cette borne est à relier à + l'alimentation stabilisée de la carte Arduino. + :ground: Ces bornes sont à relier à la masse + +Montage général +--------------- + +Il y a trois types de bornes sur le composant : celles destinées à être +connectées au moteur (`Y`), celles destinées à la carte Arduino (`EN` et `A`), +et celles qui qui servent à l'alimentation (`VCC`). Comme il est possible de +contrôler plusieurs moteurs, les bornes sont numérotées en fonction du moteur +contrôlé. + +Dans le cas d'un moteur devant tourner dans les deux sens, les bornes `Y` +doivent être connectées aux deux pattes du moteur : en envoyant du courant sur +l'une des deux bornes `A`, il devient possible de faire tourner le moteur dans +un sens ou un autre (le tableau présente l'exemple d'un moteur connecté aux +bornes `1` et `2`, un deuxième moteur pourra être contrôlé de la même manière +en le branchant sur les bornes `3` et `4`) : + +.. sidebar:: frein électromagnétique + + Le moteur génère de l'électricité en tournant (comme une dynamo). En + alimentant le moteur avec l'électricité qu'il produit lui-même, on peut ainsi + freiner le moteur avec sa propre énergie ! + +=========== =========== ============================================= +Tension 1A Tension 2A Résultat +=========== =========== ============================================= +`LOW` `LOW` Arrêt du moteur (frein électromagnétique) +`LOW` `HIGH` Faire tourner le moteur dans un sens +`HIGH` `LOW` Faire tourner le moteur en sens inverse +`HIGH` `HIGH` Arrêt du moteur (frein électromagnétique) +=========== =========== ============================================= + +Voir le schéma de branchement avec deux moteurs contrôlés depuis la carte +Arduino. + +.. figure:: content/arduino_l293d.pdf + :width: 100% + + L293D, Arduino et deux moteurs + + Les cables reliant le L293D à la masse, et l'alimentation des moteurs ne sont + pas représentés. + + :Cable bleu: Marche avant + :Cable vert: Marche arrière + :Cable orange: Puissance du moteur + +.. raw:: latex + + \pagebreak + +Programme +--------- + +.. sidebar:: Valeurs + + Les valeurs ne sont pas choisies par hasard : elles correspondent aux + paramètres des fonctions `digitalWrite` et `analogWrite` ! + +Ce programme n'est pas disponible dans l'environnement Arduino, cette fois nous +allons devoir l'écrire nous même. Afin de simplifier l'écriture, nous allons +définir une fonction `runMotor` qui prendra trois paramètres : + +:motor: Le numéro du moteur à activer, le 1er moteur déclaré aura la numéro `0` +:direction: La direction du moteur, elle peut prendre deux valeurs `HIGH` ou + `LOW` +:speed: La vitesse de rotation, cette valeur peut aller de `0` à `255` + +.. code-block:: arduino + + void runMotor(int motor, int direction, int speed) { + // … + } + + +.. admonition:: Contrôle du moteur + :class: exercice + + Avec la fonction `runMotor`, nous pouvons donner du mouvement au robot. En + donnant des paramètres de sens et de vitesse différents à la roue gauche et + droite le robot se déplacera différement. Donnez les paramètres de la + fonction `runMotor` pour réaliser les actions suivantes : + + - Marche avant + - Marche arrière + - Faire tourner le robot sur lui-même + - Faire un virage serré + - Faire un virage large + - Arrêt complet + +.. ========================= ========================= ========================== +.. Moteur 1 Moteur 2 Effet +.. ========================= ========================= ========================== +.. `runMotor(0, HIGH, 255)` `runMotor(1, HIGH, 255)` Marche avant +.. `runMotor(0, LOW, 255)` `runMotor(1, HIGH, 255)` Tourner sur lui-même +.. `runMotor(0, HIGH, 255)` `runMotor(1, LOW, 255)` Tourner sur lui-même (sens +.. inverse) +.. `runMotor(0, LOW, 255)` `runMotor(1, LOW, 255)` Marche arrière +.. `runMotor(0, LOW, 0)` `runMotor(1, HIGH, 255)` Virage serré +.. `runMotor(0, HIGH, 127)` `runMotor(1, HIGH, 255)` Virage large +.. `runMotor(0, LOW, 0)` `runMotor(1, LOW, 0)` Arrêt complet +.. ========================= ========================= ========================== + +Connecter un écran Nokia 5110 +============================= + +.. sidebar:: L'écran LCD + + .. image:: content/s-l500.jpg + :align: center + :width: 100% + +L'écran Nokia 5110 est un composant de base et peu honéreux (environ 2€) +permettant un affichage depuis la carte Arduino. Il permet un affichage sur une +grille de 84x48 pixels, soit 4 lignes de textes. + +.. admonition:: Tension de fonctionnement + :class: warning + + Le composant fonctionne sous 3,3 |V|, il n'est donc pas recommandé de le + brancher directement sur la carte Arduino (même si certains le font [#]_). + Dans le doute, commencez avec un correcteur de courant. + +.. [#] https://circuitdigest.com/microcontroller-projects/nokia5110-graphical-lcd-arduino-interfacing + +Level shifter 74HC4050N +----------------------- + +Ce composant est *unidirectionnel* et *High to Low* : en alimentant le +composant en 3.3 |V|, nous avons la possibilité de générer une sortie à 3.3 |V| +à partir de la carte Arduino : le composant possède 6 entrées et 6 sorties : à +chaque fois que la tension sur une borne d'entrée est supérieure à la tension +d'alimentation, la sortie correspondante sera activée. + +.. admonition:: Broches non connectées + :class: note + + Deux bornes ne sont pas connectées sur le composants : les bornes `13` et + `16`. Attention au moment du cablage ! + +.. sidebar:: Cablage + + Le cablage sur le composant `74HC4050N` importe peu, tant que chaque entrée + est bien associée à la sortie correspondantes. + +.. figure:: content/nokia_5110.pdf + :width: 100% + + Arduino, Nokia 5110, 74HC4050N + + :Cable Rouge: +3.3 |V| + :Cable Noir: Masse + :Cable Vert: Broche 7 - 3 (SCE) + :Cable Bleu: Broche 6 - 4 (RST) + :Cable Orange: Broche 5 - 5 (D/C) + :Cable Maron: Broches 11 - 6 (DN(MOSI)) + :Cable Cyan: Broche 13 - 7 (SeriaL CLock) + :Cable Mauve: Broche 9 - 8 (LED) + + +Le programme [#]_ + +.. image:: content/nokia_5110_montage.jpg + :width: 100% + + +.. [#] https://learn.sparkfun.com/tutorials/graphic-lcd-hookup-guide + + +.. default-role:: literal +.. role:: smallcaps +.. role:: index +.. |lcd| replace:: :smallcaps:`lcd` +.. |usb| replace:: :smallcaps:`usb` + |