path: root/notes_arduino.rst

.. -*- mode: rst -*-
.. -*-  coding: utf-8 -*-

.. default-role:: literal
.. role:: smallcaps
.. role:: index
.. |led| replace:: :smallcaps:`led`

.. include:: resources/units.rst

.. sectnum::
  :depth: 2

.. role:: raw-latex(raw)
   :format: latex

****************
La carte Arduino
****************

.. .. include:: tmp/version.rst

.. image:: content/ARDUINO_UNO_DIP_01.png
    :width: 50%
    :align: center

.. contents::
  :depth: 2

..  A partir de maintenant, on insère un saut de page avant chaque nouvelle
    section, et l'on redéfini l'espace après le titre de la section.

.. raw:: latex

    \newcommand{\sectionbreak}{\clearpage}
    \titlespacing*{\section}{0pt}{1.1\baselineskip}{100pt}

===============================
Les sorties de la carte Arduino
===============================

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…).

.. sidebar:: Chargement

  Ce programme est disponible dans l'environnement Arduino dans les exemples :
  Basic / Blink


.. admonition:: Clignotement d'une |led|
  :class: floatprogram

    .. 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).

.. sidebar:: Tension ?

    La tension est une mesure permettant d'évaluer une *différence de
    potentiel* entre deux endroits du circuit. La tension fournie par
    l'alimentation correspond à cette différence entre les deux bornes du
    générateur. De la même manière, chaque composant possède également une
    tension, que l'on peut mesurer au moment de l'utilisation du 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

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.

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

.. admonition:: Luminosité
  :class: floatprogram

    .. 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
==============

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.

.. sidebar:: Un piezzo buzzer

  .. image:: content/piezzo_buzzer.jpg
    :align: center
    :width: 100%

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 : le circuit
  intègre des diodes de protections et des contrôleurs thermiques en cas de
  surchauffe.
- 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.

.. admonition:: Faire sans
  :class: note

  Il est 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)
=========== =========== =============================================

Le schéma :raw-latex:`\ref{fig:arduino_l293d}` présente le branchement de 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:`\label{fig:arduino_l293d}`


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
=============================

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.

.. sidebar:: L'écran LCD

  .. image:: content/s-l500.jpg
    :align: center
    :width: 100%

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

===============================
Les entrées de la carte Arduino
===============================

Maintenant que nous avons vu comment contrôler les sorties de la carte Arduino,
il est temps de se poser la question d'utiliser les entrées de la carte : c'est
par ce moyen que nous allons pouvoir donner un peu de réaction à notre robot, à
travers des capteurs qui nous fournirons des informations sur le monde
extérieur.

Utiliser Arduino comme ohmmètre
===============================

Lecture de la tension
---------------------

Il existe six ports sur la carte Arduino permettant de lire des valeurs
analogiques (`A0` — `A5`).

Par exemple, la tension peut être lue le port `A0` sur avec l'instruction
:index:`analogRead` `analogRead(A0)` [#]_.  Celle-ci est lue sur dix bits (soit
une valeur comprise entre `0` et `1023`), en fonction de la tension
d'alimentation de la carte Arduino (normalement 5 |V|).

.. [#] https://www.arduino.cc/en/Reference/AnalogRead

.. raw:: latex

  \begin{center}
  \begin{tikzpicture}[scale=2.5]

  \foreach \x in {0,0.5,...,5} {
    \pgfmathtruncatemacro\result{\x * 1023 / 5}
    \draw (\x,-4pt) -- (\x,4pt)
        node [below,yshift=-20] {\pgfmathprintnumber{\result}}
        node [above] {$\x$ V};
  }

  \draw (0,0) -- (5.0,0);

  \end{tikzpicture}
  \end{center}

.. note::

  Lors de l'écriture sur un port analogique, la précision est réalisée sur huit
  bits (soit une valeur comprise entre `0` et `255`). Attention donc en
  redirigeant l'entrée d'un port vers une sortie !

On peut donc utiliser la carte comme un voltmètre simple, pour mesurer une
tension entre 0 |V| et la tension d'alimentation (5 |V|). La formule suivante
permet de calculer la tension en fonction de la valeur retournée par la
fonction `AnalogRead` :

.. math::

		V = \frac{5 \times \mathtt{AnalogRead()}}{1023}

Utiliser l'Arduino comme ohmmètre
---------------------------------

Notre premier montage pour illustrer la lecture d'une valeur consiste à
utiliser l'Arduino pour connaître la valeur d'une résistance. Nous allons
utiliser un *pont diviseur* (voir le schéma) avec une résistance connue, et une
autre dont on souhaitera déterminer la valeur : en lisant la tension
:math:`V_A`, il sera possible de déterminer la valeur de la résistance
inconnue.

.. figure:: content/pont_diviseur.pdf
  :width: 50%
  :align: center

  Le pont diviseur


  La plus simple représentation du diviseur de tension consiste à placer deux
  résistances électriques en série. Ce type d'association de résistances étant
  omniprésent dans les montages électriques, le pont diviseur en devient une des
  notions fondamentales en électronique.


  Il est possible de calculer facilement la valeur de :math:`V_A` dans le
  montage, à la condition de connaitre les valeurs des résistances et la valeur
  de la tension Vcc. La première formule à utiliser est celle de la loi d'Ohm qui
  permet de citer cette équation :

  .. math::

      I = \frac{V_\text{cc}}{R_1+R_2}

  En utilisant la loi d'Ohm une seconde fois, il est possible de déterminer
  l'équation suivante:

  .. math::

    V_a = R_2 \times I

  Dans la formule ci-dessous, il suffit de remplacer le courant :math:`I` par
  sa valeur équivalente (la première équation) pour déterminer facilement
  l'équation de :math:`V_A`:

  .. math::

      V_a = R_2 \times (\frac{V_\text{cc}}{R_1+R_2})

  **Exemple**

  Prenons les valeurs suivantes :

  - :math:`V_\text{cc}`: 9V
  - :math:`R_1`:         1k :math:`\Omega`
  - :math:`R_2`:         3k :math:`\Omega`

  .. math::

      V_a &= R_2 \times \frac{V_\text{cc}}{R_1 + R_2} \\
          &= 3000 \times \frac{9}{1000+3000} \\
          & = \frac{27000}{4000} \\
          &= 6.75V

  La différence de potentiel :math:`V_A` sera égal à 6.75 |V| en utilisant les valeurs
  précédentes.

Dans notre cas, nous connaissons la tension ainsi que la valeur de la
résistance :math:`R_2`. Donc en reprenant la formule du calcul de :math:`V_A`
nous obtenons :

.. math::

    %V_a &= R_2 \times \frac{V_\text{cc}}{R_1 + R_2} \\
    %(R_1 + R_2) \times V_a &= R_2 \times V_\text{cc} \\
    %R_1 \times V_a + R_2 \times V_a &= R_2 \times V_\text{cc} \\
    %R_1 \times V_a &= R_2 \times V_\text{cc} - R_2 \times V_a \\
    %R_1 &= \frac{R_2 \times V_\text{cc}}{V_a} - \frac{R_2 \times V_a}{V_a} \\
    %R_1 &= \frac{R_2 \times V_\text{cc}}{V_a} - R_2 \\
    %R_1 &= R_2 \times \left(\frac{V_\text{cc}}{V_a} - 1\right) \\
    R_1 &= R_2 \times \left(\frac{1023}{\mathtt{AnalogRead()}} - 1\right)

.. .. note::
..
..
.. 	La dernière ligne du calcul peut se retrouver ainsi : on sait que la tension
.. 	lue par fonction `analogRead()` est échelonée de `0` à `1023` par rapport à
.. 	la tension d'alimentation, ce que l'on peut représenter dans la ligne
.. 	suivante :
..
.. 	.. math::
..
.. 		V_A &= \frac{V_\text{cc} \times \mathtt{AnalogRead()}}{1023} &&	\text{donc} \\
.. 		\frac{V_\text{cc}}{V_A} &= \frac{V_\text{cc}}{\frac{V_\text{cc} \times \mathtt{AnalogRead()}}{1023}} \\
.. 		\frac{V_\text{cc}}{V_A} &= V_\text{cc} \times {\frac{1023}{V_\text{cc} \times \mathtt{AnalogRead()}}} \\
.. 		\frac{V_\text{cc}}{V_A} &= \frac{1023}{\mathtt{AnalogRead()}}

Contrôle théorique
~~~~~~~~~~~~~~~~~~

Le programme :raw-latex:`\ref{prg:ohmPython}` permet de prédire les différentes
valeurs qui seront lues par la carte Arduino. Il reproduit (dans une certaine
mesure) les erreurs d'arrondis qui seront susceptible d'arriver sur la carte
lors du calcul des valeurs.

.. sidebar:: Programme

  Ce programme va calculer la tension :math:`V_A`, la valeur lue par la fonction
  `analogRead`, la valeur de la résistance calculée, et l'intensité qui
  traverse les composants.

.. admonition:: Simulateur en python
  :class: floatprogram

  :raw-latex:`\label{prg:ohmPython}`

    .. include:: content/ohm.py
      :code: python

Il permet de construire le tableau de valeurs suivant (avec :math:`R_2` = 1000
:math:`\Omega`, et :math:`V_\text{cc}` = 5 |V|) :

.. sidebar:: Tension théorique

  Ce tableau est construit à partir de la différence de potentielle théorique
  au niveau de la résistance :math:`R_2`. Les valeurs réelles seront toujours
  légèrement différentes lors du montage.

=================== ================= ============= ===================
Résistance          Tension théorique Valeur lue    Résistance calculée
=================== ================= ============= ===================
10   :math:`\Omega` 4,95 |V|          1012          10
220  :math:`\Omega` 4,1  |V|          838           220
1k   :math:`\Omega` 2.5  |V|          511           1 001
10k  :math:`\Omega` 0,45 |V|          93            10 000
220k :math:`\Omega` 0,02 |V|          4             254 750
=================== ================= ============= ===================

Au delà de 220k :math:`\Omega`, la tension qui traverse :math:`R_2` devient si
faible que la valeur lue par la fonction `analogRead` tombe à `0`, ce qui
empêche toute mesure. En prenant une valeur plus importante pour la résistance
:math:`R_2`, la plage d'erreur sera plus faible pour des valeurs plus
importante de :math:`R_1`

Montage
-------

Le montage reste simple à mettre en place, il ne nécessite que deux résistances
(dont celle dont on souhaite calculer la valeur).

.. figure:: content/arduino_ohmetre.pdf
  :width: 70%

  Arduino comme ohmmètre

  La résistance :math:`R_1` sera calculée en fonction de la valeur de
  :math:`R_2`.

  La résistance :math:`R_2` peut être choisie avec une valeur de
  1000 :math:`\Omega` par défaut, et changée en fonction du besoin.

Le programme :raw-latex:`\ref{ohmetre}` reprend la formule que nous avons calculé ci-dessus, et affiche le
résultat sur la console.

.. sidebar:: pinMode

    Contrairement à notre premier programme, l'instruction `pinMode` n'est pas
    appellée. En effet, par défaut, toutes les bornes du microcontrolleur sont
    déclarées en mode `OUTPUT`.

.. admonition:: Ohmmètre
  :class: floatprogram

  :raw-latex:`\label{ohmetre}`

    .. code-block:: arduino

      // La résistance r2 doit être connue et
      // renseignée dans le programme
      int r2 = ...;

      void setup() {
        Serial.begin(9600);
      }

      void loop() {

        int r1 = r2 * ((1023 / (float)analogRead(A0)) - 1);

        Serial.print("R1: ");
        Serial.println(r1);

        delay(1000);// wait for a second
      }

.. note::

  Nous découvrons à l'occasion de ce programme la librairie `Serial` [#]_ qui
  permet d'envoyer des données à l'ordinateur via le port |usb|. Il s'agit d'un
  moyen pratique pour transmettre une valeur lue sur la carte.

  Nous pourrions enrichir ce schéma avec une sortie sur un écran |lcd| plutôt
  que d'envoyer l'information vers l'ordinateur : nous aurons ainsi un ohmmètre
  autonome !

.. [#] https://www.arduino.cc/en/Serial/Print


Capteur de proximité infrarouge
===============================

Dans un projet de robot mobile, il est nécessaire de tester la présence
d'objets à proximité pour éviter que celui-ci ne percute les obstacles.

.. sidebar:: Capteur infrarouge

  .. image:: content/Sharp_GP2Y0A21YK.jpg
    :align: center
    :width: 100%

Nous retrouvons deux types de senseurs sur les robots : des senseurs
optiques, ou par ultrasons. Le senseur Sharp relève de la première catégorie.
Il permet de détecter la présence d'un objet entre 10 et 80 cm, à partir du
retour de lumière infrarouge.

Montage général
---------------

Le schéma suivant indique comment placer les différents câbles du connecteur
:smallcaps:`JST`.

.. sidebar:: Condensateur

  Le condensateur présent sur le schéma permet ici de lisser les variations de
  la tension. On l'appelle *Condensateur de découplage* [#]_.

.. [#] https://fr.wikipedia.org/wiki/Condensateur_de_d%C3%A9couplage

.. figure:: content/capteur_infra.pdf
  :width: 100%

  Arduino, `GP2Y0A21YK`

  :Cable Rouge: +5 |V|
  :Cable Noir: GND/Masse
  :Cable Jaune ou Blanc: Entrée Analogique `A0`

.. sidebar:: Tension d'entrée

  Même si le composant supporte une tension allant jusque 7 |V|, il fonctionne de
  manière optimale avec des valeurs allant de 4,5 à 5,5 |V|.

La tension de sortie, sur le fil jaune, nous indique la distance de l'objet.
Celle-ci varie entre 0,5 |V| et 3 |V| selon la distance de l'obstacle (voir le
schéma :raw-latex:`\ref{fig:gp2y0a21yk_e}` repris de la documentation technique
du constructeur [#]_).


.. [#]  http://www.sharp-world.com/products/device/lineup/data/pdf/datasheet/gp2y0a21yk_e.pdf

.. figure:: content/gp2y0a21yk_e.pdf
  :width: 100%

  Mesure de la tension en fonction de la distance

  :raw-latex:`\label{fig:gp2y0a21yk_e}`

Exemple
~~~~~~~

Ce programme lit l'entrée sur la broche `A0` et allume une |led| si un objet
est détecté à proximité (±20 |cm|) :

.. admonition:: Détecteur d'objet
  :class: floatprogram

    .. code-block:: arduino


      int ledPin = 9;    // LED connected to digital pin 9

      void setup()  {}

      void loop()  {
        int sensorValue = analogRead(A0);
        if (sensorValue < 220)
          sensorValue = 0;

        analogWrite(ledPin, sensorValue >> 2);
        delay(200);            // delay 200 milliseconds
      }

.. Déclencher le capteur sur demande
.. ---------------------------------
..
.. Plutôt que d'activer le capteur en continu, nous allons modifier le programme
.. pour n'activer la détection d'objets seulement en cas de mouvements du robot
.. (il n'est pas nécessaire de chercher à tester les obstacles si le robot ne se
.. déplace pas). Cela permettra d'augmenter l'autonomie du robot (en contre-partie
.. d'un port digital utilisé). La consommation du composant étant de 30 |mA|, nous
.. pouvons connecter directement la broche à l'Arduino, il sera capable de fournir
.. le courant nécessaire.
..
.. Le capteur nécessite un délai minimal avant de fournir une valeur fiable.
..
.. Créer une tension seuil
.. -----------------------
..
.. Nous n'avons pas un besoin réel d'évaluer la distance de l'objet, simplement de
.. pouvoir arrêter le robot s'il s'approche trop près d'un objet. Si l'on connaît
.. la distance d'arrêt souhaitée (et donc la tension) avant de construire le
.. robot, nous pouvons paramétrer le seuil de déclenchement de l'alarme, et
.. utiliser une broche digitale au lieu d'une broche analogique.


Utiliser un bouton poussoir
===========================

Un bouton poussoir est un composant simple, permettant d'ouvrir ou fermer le
circuit selon que le bouton est pressé ou enfoncé. En reliant le bouton à l'une
des entrées de la carte Arduino, on peut ainsi interagir avec des actions de
l'utilisateur.

.. sidebar:: Un bouton poussoir

  .. image:: content/Push-Button-Switch.jpg
    :align: center
    :width: 75%

Pour le tester, écrivons un petit programme qui allume une |LED| dès que le
bouton est pressé :

.. admonition:: Ça ne fonctionne pas !
  :class: warning

  Ce branchement pose un problème : en effet, la fonction `digitalRead` lit une
  tension au niveau de la borne. Or, nous avons dit plus haut que la tension
  était la mesure d'une différence de potentiel. Pour être plus précis, la
  fonction mesure une différence entre le potentiel de la borne, et la masse
  (qui sert toujours de référence). Ici, le circuit est ouvert, la mesure ne
  peut donc pas être valide !

  Il faut mettre en place une solution pour que le circuit soit *toujours*
  relié à la masse, même quand le bouton est relaché.

Il faut également veiller à ce que cette liaison à la masse ne vienne pas
court-circuiter notre branchement : quand le bouton est pressé il faut que le
courant passe par le microcontrolleur.

Résistance de rappel
--------------------

Ce problème peut être résolu en ajoutant une résistance sur le schéma.
Celle-ci ne sera *jamais* utilisée dans le circuit électrique, mais sert
uniquement à éviter de laisser un système ouvert.

.. sidebar:: Pull-down

  La résistance sert à amener un état *bas* à la broche. En anglais, on emploi
  le terme *Pull-Down* pour évoquer cet usage.

.. figure:: content/bouton_pulldown.pdf
  :width: 100%

  Résistance de rappel

  La résistance ici ne consomme pas de courant :

  - Quand l'interrupteur est ouvert, aucun courant ne circule dans le circuit
    (le cablage n'est pas relié à l'alimentation)
  - Quand l'interrupteur est fermé, le courant passe par la borne plutôt que la
    résistance.


Résistance de tirage
--------------------

On peut imaginer le schéma similaire, en inversant la position du bouton et de
la résistance. À ce moment, le courant arrive à la broche dès que
l'interrupteur est ouvert. Dans le programme, il faut donc considérer que le
bouton est appuyé quand on lit `DOWN` sur la broche, et le bouton relaché dès
que l'on lit `HIGH`.

=========================
L'alimentation du système
=========================

USB
===

L'|usb| fourni une tension de 5 |V| avec une intensité maximale de 100 |mA| sur
les bornes d'alimentation. Il est donc possible d'alimenter une carte Arduino
avec un câble |usb| (c'est d'ailleurs ainsi que l'on procède lorsque l'on
programme la carte).

Source externe
==============

.. sidebar:: Régulateur LM1117

  .. image:: content/LM1117.jpg
    :align: center
    :width: 75%

La carte Arduino possède un régulateur de tension intégré capable de produire
une tension de  5 |V|. Il est donc possible d'alimenter la carte avec une
tension supérieure pour alimenter le circuit.

.. note::

  La régulation de la tension est réalisée en convertissant la puissance
  superflue en chaleur. Si la tension est trop importante, le composant va trop
  chauffer et la carte va s'abîmer.

  De même, le régulateur consomme également du courant en fonctionnement,
  donner une tension de 5 |V| sera trop juste pour alimenter le circuit.

  Aussi, la tension recommandée pour un bon fonctionnement est comprise entre 7
  à 12 |V|.

.. sidebar:: Attention au sens !

  En inversant le sens des fils entre la masse et l'alimentation, on applique
  l'opposé de la tension attendue, ce qui ne plaira pas beaucoup au circuit !
  [#]_

.. [#] https://www.rugged-circuits.com/10-ways-to-destroy-an-arduino

Il existe deux points de connexions sur la carte permettant d'utiliser le
régulateur de tension : la prise jack, ainsi que la borne `Vin`.

Alimentation via prise jack
---------------------------

Il s'agit de la manière la plus simple pour alimenter le circuit, puisque la
carte Arduino possède une prise Jack. En respectant les limites des tensions
indiquées ci-dessus, il ne reste qu'à brancher la fiche sur la carte.

Dans le cas d'un transformateur externe, il faut veiller à ce que symbole suivant

.. image:: content/polarity.pdf
  :width: 25%
  :align: center

soit présent sur la carte : c'est à dire que le fil `+` soit connecée au centre
de la borne d'alimentation.

Alimentation directe sur la carte
---------------------------------

La borne `Vin` permet de connecter directement une alimentation à la carte :
elle est également reliée au régulateur de tension et supporte donc une tension
supérieure jusque 12 |V|.

Là encore, il faut veiller à connecter les deux fils sur les bonnes bornes : la
carte Arduino n'offre aucune protection en cas d'erreur…

Alimentation externe 5 |V|
==========================

.. note::

  Cette solution peut être utilisée si la tension d'entrée est supérieure à
  12 |V| : l'utilisation d'un régulateur de tension externe tel que le `LM7805`
  permettra de prendre en entrée une tension jusqu'à 20 |V|.

Si la tension externe est déjà stabilisée à 5 |V|, il n'est pas possible de se
connecter sur la broche `Vin` de la carte, puisqu'il faut au minimum du 7 |V|
pour avoir une tension de fonctionnement correcte.

Alimentation par usb
--------------------

.. sidebar:: Cable

  .. image :: content/USB-2-0-B-MALE-TO-5.jpg
    :width: 100%

La solution la plus sûre dans ce cas est de brancher cette alimentation sur
l'entrée |usb| de la carte. On gagne ainsi en sécurité, au détriment d'un petit
peu de cablage supplémentaire.

Alimentation par la broche 5V
-----------------------------

Autre solution envisageable, brancher l'alimentation directement sur la broche
`5V` de la carte Arduino : cette borne est reliée au circuit 5 |V| de la carte,
et n'est pas uniquement une borne de sortie : elle relie l'ensemble des
composants qui ont besoin d'être alimentés avec cette tension.

.. admonition:: Attention
  :class: warning

  Alimenter la carte par la prise `5V` de la carte n'est pas recommandé :

  - Étant donné que l'on passe outre le régulateur de tension, il y a un risque
    important de griller la carte si l'on applique une tension trop importante.
  - Il interdit d'utiliser en même temps la prise |usb|
  - Il interdit d'utiliser en même temps la prise `Vin` sous risque de griller
    la carte

En effet, cette prise est directement reliée au circuit 5 |V| et outrepasse
**toutes** les protections de la carte, qui n'est pas prévue pour être
alimentée ainsi. Il faut réserver cet usage a des cas particuliers (par exemple
alimenter deux cartes Arduino ensemble)

Tableau récapitulatif
=====================

Les différentes tensions admissibles :

================  =============== =============== ==============
Entrée            Tension min.    Tension max.    Intensité max.
================  =============== =============== ==============
Port USB          4,5 |V|         5,5 |V|
Broche `5V`       4,5 |V|         5,5 |V|
Prise jack        7 |V|           12 |V|
Broche `Vin`      6,6 |V|         12 |V|
================  =============== =============== ==============


==============================
Créer sa propre plaque arduino
==============================

Il suffit d'un microcontrolleur pour faire fonctionner son programme arduino,
il n'est pas nécessaire d'acheter la carte déjà montée !

.. Avec un ATMege328
.. =================
..
.. Voir le tutoriel [#]_
..
.. .. [#] https://www.arduino.cc/en/Tutorial/ArduinoToBreadboard
..
.. RBBB propose de monter soit même son arduino

Avec un AtTiny85
================

.. figure:: content/attiny_programatter.pdf
  :width: 100%

  Cablage du programmateur