path: root/chapters/output.rst

.. -*- 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`