Électronique et Informatique industrielle " Platine Arduino " - ATMEGA 328P µcontrôleur Atmel - Université de la Nouvelle ...

 
CONTINUER À LIRE
Électronique et Informatique industrielle " Platine Arduino " - ATMEGA 328P µcontrôleur Atmel - Université de la Nouvelle ...
Électronique et Informatique industrielle
                          « Platine Arduino »

                                                µcontrôleur Atmel
          Carte Arduino Uno WiFi
                                                 ATMEGA 328P

L2 Informatique - 2018         Thomas Quiniou                       1
Électronique et Informatique industrielle " Platine Arduino " - ATMEGA 328P µcontrôleur Atmel - Université de la Nouvelle ...
Électronique et Informatique industrielle
Quelques liens                          « Platine Arduino »
Arduino et Atmega :
https://www.arduino.cc/
https://www.arduino.cc/en/Guide/ArduinoUnoWiFi#toc10
https://store.arduino.cc/arduino-uno-wifi
http://www.microchip.com/design-centers/8-bit
http://www.microchip.com/wwwproducts/en/ATmega328P

Sites en ligne, quelques exemples mais il en existe bien d’autres… :
https://fr.flossmanuals.net/arduino
http://perso-laris.univ-angers.fr/~cottenceau/ArduinoCottenceau2016.pdf
https://www.tutorialspoint.com/arduino/index.htm
http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.Debuter
http://www.locoduino.org/

Gotronic, Uno wifi et Kit 40 capteurs
https://www.gotronic.fr/art-carte-arduino-uno-wifi-25350.htm#complte_desc
https://www.gotronic.fr/art-kit-de-40-capteurs-sen-x40-25414.htm

 L2 Informatique - 2018                         Thomas Quiniou                   2
Électronique et Informatique industrielle " Platine Arduino " - ATMEGA 328P µcontrôleur Atmel - Université de la Nouvelle ...
Plan
• Présentation générale des µcontrôleurs et de leurs usages
• La platine Arduino :
     –   Historique du projet
     –   Installation et prise en main rapide
     –   Les différentes platines Arduino (UNO, MEGA, PRO MINI etc)
     –   Shields pour Arduino
     –   Le matériel à votre disposition (kit 40 capteurs Arduino)
• Programmation Arduino
     – IDE Arduino, structure d’un programme
     – Syntaxe, nommage, déclaration, indentation, commentaires, sous-routines etc.
• Le µcontrôleur ATMEGA328P, architecture
• Électronique :
     – Quelques bases indispensables en électronique
     – Les entrées/sorties numériques, les entrées analogiques, les bus : exemples
• Les timers et interruptions

 L2 Informatique - 2018             Thomas Quiniou                                   3
Électronique et Informatique industrielle " Platine Arduino " - ATMEGA 328P µcontrôleur Atmel - Université de la Nouvelle ...
Présentation générale des µcontrôleurs et de
                         leurs usages
Les microcontrôleurs

     Un microcontrôleur est un circuit intégré rassemblant dans un même boitier un
     microprocesseur (généralement peu puissant), plusieurs types de mémoires et
     des périphériques de communication (Entrées-Sorties).

     Les microcontrôleurs représentent la plus grosse partie
     des ventes dans le marché des microprocesseur. En effet,
     un foyer moyen d'un pays développé est susceptible
     d'être équipé de seulement un ou deux microprocesseurs
     généralistes (ordinateurs), mais d'une ou deux douzaines
     de microcontrôleurs (appareils électroménagers).

     Les microcontrôleurs sont des composants microprogrammés. Plusieurs
     langage sont utilisés : assembleur (bas niveau), Basic, langage C et plus
     récemment C++.

 L2 Informatique - 2018             Thomas Quiniou                               4
Électronique et Informatique industrielle " Platine Arduino " - ATMEGA 328P µcontrôleur Atmel - Université de la Nouvelle ...
Présentation générale des µcontrôleurs et de
                         leurs usages

Un microcontrôleur (µC) se présente sous la forme d’un circuit intégré réunissant tous
les éléments d’une structure à base de microprocesseur. Voici généralement ce que
l’on trouve à l’intérieur d’un tel composant :

     •   un microprocesseur (C.P.U.), avec une largeur du chemin de données allant de
         4 bits pour les modèles les plus basiques à 32 ou 64 bits pour les modèles les
         plus évolués,
     •   de la mémoire vive (RAM, EEPROM) pour stocker les données et variables,
     •   de la mémoire morte (ROM) pour stocker les programmes, différentes
         technologies EPROM, EEPROM, flash,
     •   souvent un oscillateur pour le cadencement. Il peut être réalisé avec un
         quartz, un circuit RC ou encore une PLL,
     •   des périphériques, capables d'effectuer des tâches spécifiques.

 L2 Informatique - 2018                Thomas Quiniou                                 5
Électronique et Informatique industrielle " Platine Arduino " - ATMEGA 328P µcontrôleur Atmel - Université de la Nouvelle ...
Présentation générale des µcontrôleurs et de
                         leurs usages
Parmi les périphériques, on peut mentionner entre autre :

     •   les convertisseurs analogiques-numériques (CAN) (donnent un nombre binaire
         à partir d'une tension électrique),
     •   les convertisseurs numériques-analogiques (CNA) (effectuent l'opération
         inverse),
     •   les générateurs de signaux à modulation de largeur d'impulsion (MLI, ou en
         anglais, PWM pour Pulse Width Modulation),
     •   les   timers/compteurs    (compteurs   d'impulsions   d'horloge   interne   ou
         d'événements externes),
     •   les chiens de garde (watchdog),
     •   les comparateurs (comparent deux tensions électriques),
     •   les contrôleurs de bus de communication (UART, I²C, SSP, CAN, FlexRay,
         USB, Ethernet, etc.).

 L2 Informatique - 2018               Thomas Quiniou                                  6
Électronique et Informatique industrielle " Platine Arduino " - ATMEGA 328P µcontrôleur Atmel - Université de la Nouvelle ...
Présentation générale des µcontrôleurs et de
                         leurs usages
Un microcontrôleur est donc une unité de traitement de l’information de type
microprocesseur à laquelle on a ajouté des périphériques internes permettant de
réaliser des montages sans nécessiter l’ajout de composants externes.

Plusieurs constructeurs se partagent le marché des microcontrôleurs, citons INTEL,
MOTOROLA, SEAGATE-THOMSON, ATMEL, ZILOG, PHILIPS et enfin MICROCHIP
avec ses PICs très populaires.

Les µC sont basés sur 2 architectures
possibles, Von Neumann (INTEL80XX,
Motorola HC05, HC08 et HC11, ou ZILOG
Z80) ou Harvard (PIC, ATMEL).

                                                 EXEMPLES DE MICROCONTRÔLEURS

 L2 Informatique - 2018             Thomas Quiniou                               7
Électronique et Informatique industrielle " Platine Arduino " - ATMEGA 328P µcontrôleur Atmel - Université de la Nouvelle ...
Présentation générale des µcontrôleurs et de
                         leurs usages
De nombreux microprocesseurs et microcontrôleurs actuels utilisent une architecture
interne dite de Von Neumann, c’est-à-dire en fait une architecture commune à celle
que l’on rencontre habituellement dans les micro-ordinateurs. La mémoire, appelée
improprement de programme, contient en fait des instructions et des données placées
à la suite les unes des autres et l’on ne dispose que d’un bus, appelé bus de données,
pour véhiculer tour à tour les codes des instructions et les données qui leur sont
associées comme le montre la suivante.

                             Architecture « Von Neumann »

 L2 Informatique - 2018             Thomas Quiniou                                   8
Électronique et Informatique industrielle " Platine Arduino " - ATMEGA 328P µcontrôleur Atmel - Université de la Nouvelle ...
Présentation générale des µcontrôleurs et de
                         leurs usages
Si cette architecture donne toute satisfaction comme vous en avez la preuve
éclatante chaque jour, elle pose quelques problèmes dès que l’on veut faire
fonctionner l’ensemble rapidement. En effet, l’exécution d’une seule instruction
nécessite plusieurs échanges de données sur le seul et unique bus dévolu à cet usage
puisqu’il faut tout d’abord aller chercher le code de l’instruction puis la ou les données
qu’elle doit manipuler.

Il est alors préférable de faire appel à une architecture dite Harvard dans laquelle
les instructions et les données sont clairement différenciées et sont véhiculées sur
des bus différents. Vu de l’utilisateur, cela ne change rien bien sûr et les circuits de
ce type s’utilisent exactement comme les autres. En revanche, les résultats obtenus,
en termes de vitesse d’exécution des programmes, peuvent être impressionnants.

 L2 Informatique - 2018               Thomas Quiniou                                     9
Électronique et Informatique industrielle " Platine Arduino " - ATMEGA 328P µcontrôleur Atmel - Université de la Nouvelle ...
Présentation générale des µcontrôleurs et de
                         leurs usages
En effet, l’exécution d’une instruction ne fait plus appel qu’à un seul cycle machine
puisque l’on peut simultanément, grâce aux deux bus, rechercher le code de
l’instruction et la ou les données qu’elle manipule.

                                   Architecture « Harvard »

Rompant avec une tradition bien établie, les microcontrôleurs PIC de Microchip,
toutes familles confondues, ou AVR d’Atmel utilisent une architecture Harvard mais
ce n’est pas tout…

 L2 Informatique - 2018                Thomas Quiniou                              10
Présentation générale des µcontrôleurs et de
                            leurs usages
MICROPROCESSEURS RISC ET CISC

Les microprocesseurs CISC (Complex Instruction Set Computing) sont dotés d’un jeu
étendu d’instructions complexes. Ces instructions sont relativement lentes. Les
microprocesseurs CISC privilégient la puissance de traitement au détriment de la
rapidité.

Les microprocesseurs RISC (Reduced Instruction Set Computing) sont munis d’un jeu
réduit d’instructions simples (75 pour les PIC 18F, 131 pour l’ATmega328P). Ces
instructions sont adaptées et sont très rapides. Le microcontrôleur ATMEL
ATmega328P équipant la carte Arduino Uno est de type RISC.

                      ⇒ ATMEL AVR : architecture Harvard + RISC (R)

Remarque : le R du sigle AVR vient de la première lettre du terme RISC. Pour les deux autres lettres, plusieurs
versions existent : AdVanced [Risc], Advanced Virtual [Risc] ou encore Alf and Vegard [Risc] (les designers de la
première puce). Néanmoins et selon Atmel, ces 2 lettres ne veulent rien dire en particulier.

 L2 Informatique - 2018                        Thomas Quiniou                                                 11
Présentation générale des µcontrôleurs et de
                         leurs usages
Langage de programmation des µP

Les programmes peuvent être écrits à trois niveaux différents :

    – Langage évolué (Pascal, Basic, Langage C, etc),
    – Assembleur (mnémoniques et opérandes),
    – Langage machine (binaire ou hexadécimal).

Le programme binaire est transféré dans une mémoire non volatile du µcontrôleur.

 L2 Informatique - 2018              Thomas Quiniou                                12
La platine Arduino

Historique du projet (https://fr.flossmanuals.net/arduino/historique-du-projet-arduino/)

•    Projet issu d'une équipe d'enseignants et d'étudiants de l'école de Design d'Interaction
     d'Ivrea 1 (IDII, Italie).
•    Problème : avant la période 2003-2004, les outils nécessaires à la création de projets
     d'interactivité étaient complexes et onéreux. Ces coûts souvent trop élevés rendaient
     difficiles le développement par les étudiants de nombreux projets et ceci ralentissait la mise
     en œuvre concrète de leur apprentissage.
•    Jusqu'alors, les outils de prototypage étaient principalement dédiés à l'ingénierie, à la
     robotique et aux domaines techniques. Ils sont puissants mais leurs processus de
     développement sont longs et ils sont difficiles à apprendre et à utiliser pour les artistes, les
     designers d'interactions et, plus généralement, pour les débutants.
•    Leur préoccupation se concentra alors sur la réalisation d'un matériel moins cher et plus facile
     à utiliser. Ils souhaitaient créer un environnement proche de Processing, ce langage de
     programmation développé dès 2001 par Casey Reas et Ben Fry, deux anciens étudiants de John
     Maeda au M.I.T., lui-même initiateur du projet DBN.

    L2 Informatique - 2018                         Thomas Quiniou                                 13
La platine Arduino
Historique du projet, suite (https://fr.flossmanuals.net/arduino/historique-du-projet-arduino/)

•    En 2003, Hernando Barragan, pour sa thèse de fin d'études, avait entrepris le développement
     d'une    carte    électronique     dénommée        Wiring,    accompagnée        d'un    environnement   de
     programmation libre et ouvert (voir le lien https://arduinohistory.github.io/).
•    Comme pour Wiring, l'objectif du projet Arduino (2005) était d'arriver à un dispositif simple à
     utiliser, dont les coûts seraient peu élevés, les codes et les plans « libres » (c'est-à-dire dont
     les sources sont ouvertes et peuvent être modifiées, améliorées, distribuées par les
     utilisateurs eux-mêmes) et, enfin, « multi-plates-formes » (indépendant du système
     d'exploitation utilisé).
•    Le nom Arduino trouve son origine dans le nom du bar dans lequel l’équipe avait l'habitude de se
     retrouver. Arduino est aussi le nom d'un roi italien, personnage historique de la ville « Arduin
     d’Ivrée », ou encore un prénom italien masculin qui signifie « l'ami fort ».

    L2 Informatique - 2018                        Thomas Quiniou                                              14
Les différentes platines « Officielles » Arduino
       https://www.arduino.cc/en/Main/Products?from=Main.GenuinoProducts
       https://www.arduino.cc/en/Products/Compare

       UNO (20€)                      MEGA 2560 (40€)                      PRO MINI (16€)

L2 Informatique - 2018                 Thomas Quiniou                                       15
Les Shields Arduino
         http://shieldlist.org/

Les shields permettent d’ajouter des fonctionnalités à la carte
Arduino : vidéo, son, réseau (WiFi, GSM etc.), connecteur, capteurs
etc. Il est possible d’en mettre plusieurs et de les empiler les unes
sur les autres.

Quelques exemples :

RTC/SD                            GSM/GPRS                              Multi-Camera

 L2 Informatique - 2018                  Thomas Quiniou                                16
Exemples de projets
https://create.arduino.cc/projecthub

Les cartes Arduino ayant été conçues avec l’objectif d’être facile d’accès,
il n’est pas nécessaire d’être électronicien ou informaticien pour les mettre
en œuvre. Du coup, les exemples de projets et les applications sont
extrêmement nombreux et variés (robotique, station météo, domotique, jeu
de lumière etc.) et de complexité plus ou moins importante.

Robot                                  Station météo                      Jeu de LEDs

 L2 Informatique - 2018                       Thomas Quiniou                            17
Liste du matériel à votre disposition
                                                      (Merci d’en prendre soin!)
             Une carte Arduino WiFi                              Une plaque de prototypage (BreadBoard), des fils de
                                                                 connexion, des résistances et un cordon USB

                                                                 Une module RTC (Real Time Clock)
  https://www.gotronic.fr/art-carte-arduino-uno-wifi-25350.htm
                                                                 https://www.gotronic.fr/art-module-horloge-temps-reel-ada3295-25537.htm
             Kit de 40 capteurs SEN-X40                          https://github.com/adafruit/RTClib

                                                                 Un lecteur de carte µSD
                                                                 https://www.gotronic.fr/art-module-carte-
                                                                 micro-sd-dev-13743-24810.htm

                                                                 Un afficheur LCD 2X16
                                                                 https://www.gotronic.fr/art-afficheur-lcd-2x16-i2c-ld1602i2c-25386.htm
                                                                 https://www.arduinolibraries.info/libraries/liquid-crystal-i2-c

                                                                 Un adaptateur secteur AC/DC réglable
                                                                     https://www.gotronic.fr/art-adaptateur-psu10rs-
https://www.gotronic.fr/art-kit-de-40-capteurs-sen-x40-25414.htm     8143.htm
https://drive.google.com/file/d/0BxFOZP_yVG0lTE16cVVNQ1c3WVk/view

      L2 Informatique - 2018                                 Thomas Quiniou                                                           18
La platine Arduino UNO

L2 Informatique - 2018    Thomas Quiniou   19
La platine Arduino UNO

                                                Bouton Reset

                         Connecteur ICSP (Programmation du µcontrôleur
                         sans passer par l’USB)
L2 Informatique - 2018    Thomas Quiniou                                 20
IDE Arduino
Installation et prise en main rapide

L‘IDE Arduino permet de créer et d’éditer un programme (appelé sketch) qui sera
compilé puis téléversé sur la carte Arduino. Ainsi, lorsque vous apportez des
changements sur le code, ces changements ne seront effectifs qu'une fois le
programme téléversé sur la carte.
L’IDE peut être téléchargé gratuitement sur votre machine ou mis en œuvre
directement          en     ligne.     Rendez        vous      sur     le     site     Arduino        à    l’adresse
https://www.arduino.cc/ et cliquez sur le bouton software.
Dans le cadre de ce cours, nous allons utiliser la version en ligne « ARDUINO WEB
EDITOR ». Créer un compte, connectez vous et rendez vous sur la page web de l’IDE.

(https://create.arduino.cc/projecthub/Arduino_Genuino/getting-started-with-arduino-web-editor-on-various-platforms-4b3e4a)

  L2 Informatique - 2018                           Thomas Quiniou                                                   21
L ’Editeur WEB Arduino

Pourquoi l’éditeur web Arduino?
 (https://wiki.electroniciens.cnrs.fr/index.php/Arduino_Web_Editor)

L'Arduino Web Editor sera toujours à jour, y compris les dernières bibliothèques et
les "Cores" (support pour différentes cartes), sans avoir à installer quoi que ce soit.
Les différentes cartes sont automatiquement disponibles depuis un seul menu
déroulant. Des exemples sont présentés avec les détails Schematics et Layout. Vous
pouvez également ajouter des PNG personnalisés à vos propres croquis, de sorte que
tous les éléments essentiels de votre projet soient en un seul endroit.

Vous pouvez également importer tout votre carnet de croquis (programme Arduino) et
partager tout esquisse que vous faites sur l'éditeur Web en partageant simplement
son URL.

 Licence SPI2 - 2018                                Thomas Quiniou                   22
L ’Editeur WEB Arduino
 Sites à consulter :
 https://create.arduino.cc/projecthub/Arduino_Genuino/getting-started-with-arduino-web-editor-on-various-platforms-4b3e4a
 http://www.c-sharpcorner.com/article/guide-to-arduino-web-editor/

L’éditeur WEB
comporte 3 zones :

                   Navigation                                                                 Zone de Codage
                                                 Affichage des options
                                                 selon le menu sélectionné
 L2 Informatique - 2018                           Thomas Quiniou                                                   23
L ’Editeur WEB Arduino
Un premier exemple : Hello World

•    Connectez votre carte Arduino wifi sur votre PC à l’aide du câble USB
•    Si besoin, téléchargez et installez le plugin Arduino pour Windows

                                                           1.   Assurez vous que votre carte Uno
                                                                WiFi est bien reconnue
          2                  4            1                2.   Créez un nouveau sketch
                                 5                              « Hello_World .ino»
                                                           3.   Recopiez le programme
                                                           4.   Cliquez sur le bouton « Verifiy »
                                                           5.   Cliquez sur le bouton « Upload »
                                     3
                                                           6.   Cliquez sur le bouton « Monitor »
      6

    L2 Informatique - 2018               Thomas Quiniou                                    24
L ’Editeur WEB Arduino
Un second exemple : LED Blinking

•    Cliquez sur l’onglet « Examples » de la zone 1
•    Dans la zone 2, sélectionnez « 01.Basics » puis « Blink »
•    Le code s’affiche dans la zone 3

                                                             •   Vérifiez le code
                                                             •   Chargez le code
                                                             •   Vérifiez que la LED clignote
                                                             •   Analysez le code

    L2 Informatique - 2018              Thomas Quiniou                                  25
L ’Editeur WEB Arduino
L’onglet « Librairies »

•    Cliquez sur l’onglet « Examples » de la zone 1
•    Dans la zone 2, sélectionnez « 01.Basics » puis « Blink »
•    Le code s’affiche dans la zone 3

                                                            •    Vérifiez le code
                                                            •    Chargez le code
                                                            •    Vérifiez que la LED clignote
                                                            •    Analysez le code

    L2 Informatique - 2018              Thomas Quiniou                                  26
Le langage Arduino
(https://www.arduino.cc/reference/en/)

Comme vous avez pu le constater avec les deux exemples précédents, le langage Arduino est très
proche du C. Mais pas seulement, il intègre aussi des fonctionnalités empruntés au C++ : la syntaxe
nom.fonction() n’existe pas en C pur, c’est du C++. Par exemple, Serial est un objet auquel sont
associés des attributs (begin, print etc.).

Structure
La structure d’un code Arduino contient à minima deux fonctions, la fonction setup() et la fonction loop().

 L2 Informatique - 2018                       Thomas Quiniou                                            27
Le langage Arduino
(https://playground.arduino.cc/French/Setup)

 La fonction setup()
 La fonction setup() est appelée au démarrage du programme. Cette fonction est utilisée pour initialiser les
 variables, le sens des broches, les librairies utilisées. La fonction setup n'est exécutée qu'une seule fois, après
 chaque mise sous tension ou reset (réinitialisation) de la carte Arduino.
 La fonction setup(), même vide, est obligatoire dans tout programme Arduino.
 Pour comprendre : les habitués du C seront surpris de ne pas trouver la classique fonction main() obligatoire dans
 tout programme C. En fait, la fonction setup() et la fonction loop() sont implémentées au sein de la fonction
 main() qui est appelée en premier lors de l'exécution de tout programme en C, langage sur lequel est basé le
 langage Arduino.

 L2 Informatique - 2018                           Thomas Quiniou                                                  28
Le langage Arduino
(https://playground.arduino.cc/French/Loop)

 La fonction loop()
 Après avoir créé une fonction setup(), qui initialise et fixe les valeurs de démarrage du programme, la fonction
 loop () (boucle en anglais) fait exactement ce que son nom suggère et s'exécute en boucle sans fin, permettant à
 votre programme de s'exécuter et de répondre. Utiliser cette fonction pour contrôler activement la carte
 Arduino.
 La fonction loop() est obligatoire, même vide, dans tout programme.

 Licence SPI2 - 2018                            Thomas Quiniou                                                 29
Le langage Arduino : Structure
(https://www.arduino.cc/reference/en/)

 L2 Informatique - 2018                  Thomas Quiniou   30
Le langage Arduino : Variables
(https://www.arduino.cc/reference/en/)

 L2 Informatique - 2018                  Thomas Quiniou   31
Le langage Arduino : Fonctions prédéfinies
(https://www.arduino.cc/reference/en/)

 L2 Informatique - 2018                  Thomas Quiniou   32
Le langage Arduino : quelques règles
(https://fr.flossmanuals.net/arduino/comment-bien-structurer-son-code/)

 Conventions de nommage
 La syntaxe d'un langage de programmation se base généralement sur une « convention de nommage ». Il est
 important de respecter cette nomenclature pour rester dans l'esthétique du code.
 Dans la déclaration des variables, il faut écrire les constantes en majuscule :

                              const int CAPTEUR = A0; // CAPTEUR est une constante.

 Pour les autres variables (int, char, etc.), les fonctions et les sous-routines seront en minuscule. Dans le cas où
 ces variables ont des noms composés, le premier mot est en minuscule et les autres commencent par une
 majuscule. Par exemple :
                                                 int bookSprint = 2011;

 Pour les sous-routines (http://plaisirarduino.fr/les-fonctions/), la règle est identique à celle des variables composées.
 Par exemple :
                                               afficherValeurCapteur ();

 Déclarer ses variables
 Le nom des éléments (capteurs, actionneurs, etc. ) utilisés dans un projet sont généralement repris par les
 variables du programme qui fait fonctionner le dispositif. Cette pratique permet de clarifier la fonction des
 différentes variables. Par exemple pour choisir une variable qui a pour fonction de définir le port sur lequel est
 connectée une LED, nous choisirons la variable suivante :
                                                   int brocheLed = 13;
 L2 Informatique - 2018                             Thomas Quiniou                                                     33
Le langage Arduino : quelques règles
(https://fr.flossmanuals.net/arduino/comment-bien-structurer-son-code/)

 Indenter son code : il est conseillé d'effectuer un retrait par rapport à la ligne précédente à chaque nouveau
 bloc d'instructions. Les blocs d'instructions inscrits dans les fonctions et boucles sont délimités par des
 accolades, l'une est ouvrante et l'autre fermante.

                                 Code non indenté                                          Code indenté
                         if (etatCaptation == 1) {                          if (etatCaptation == 1) {
                         if (valeurCapteur >= seuil) {                         if (valeurCapteur >= seuil) {
                         analogWrite (pinLed, HIGH);}                             analogWrite (pinLed, HIGH);
                         }                                                     }
                                                                            }

 Il est à noter qu'un code indenté est plus attrayant et lisible. C'est un aspect qui facilite la recherche d'erreurs
 éventuelles qui pourraient se glisser dans le code.

 Faire des commentaires : il n'y a rien de plus embêtant qu'une instruction écrite dans un code et dont on a oublie
 l'utilité quelques jours après. Les commentaires permettent de se retrouver dans son code. Ils facilitent en
 outre la compréhension du code pour ceux qui en auront éventuellement besoin.

                                                    Ci-dessous,   un   commentaire   sur    plusieurs   lignes   explique   le
                                                    fonctionnement du programme

 L2 Informatique - 2018                             Thomas Quiniou                                                               34
http://www.microchip.com/wwwproducts/en/ATmega328P

                                   Le µcontrôleur ATMEGA328P
                                   (Page 25 de la datasheet)

                                                               µProcesseur 8bits       Mémoires (Page 34 de la datasheet)

                                                                                                           http://www.mon-club-
                                                                                                           elec.fr/pmwiki_reference_arduino/pmwiki.php
                                                                                                           ?n=Main.PortManipulation

                                                                                                                   (Page 97 de la datasheet)
                                                                                                           - Ports B et D : Broches numériques
                                                                                                           (8 à 13 et 0 à 7)
       Horloge                                                                                             - Port C: Broches
                                                                                                           analogiques/numériques
       (Page 48 de la datasheet)
                                                                                                                      Timer/Counter 0
                                                                                                                      Port SPI
                                                                                                                      (Serial Peripheral Interface)

                                                                                                                         (Page 215 de la datasheet)
  (Page 305 de la datasheet)
    Convertisseur                                                                                                            Analog Comparator
                                                                                                                             (Page 299 de la datasheet)
Analogique/numérique
    Interruption                                                                            Port Série (Universal Synchronous
      externe                                                                               Asynchronous Receiver Transceiver)
 (Page 87 de la datasheet)                                                                            (Page 225 de la datasheet)

  Timer/Counter
                                                                                            2-Wire Serial Interface (I2C)
      1&2                                                                                       (Page 260 de la datasheet)
 (Page 186 de la datasheet)

      http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_Datasheet.pdf

          L2 Informatique - 2018                                    Thomas Quiniou                                                           35
Le µcontrôleur ATMEGA328P
http://quai-lab.com/arduino-ses-memoires/
https://www.carnetdumaker.net/articles/reduire-lempreinte-memoire-dun-programme-arduino-avec-progmem/

Les mémoires

La mémoire est l’un des principaux composants d’un ordinateur ou d’un microcontrôleur comme
l’Atmega, cœur de l’arduino. Les mémoires des AVR sont au nombre de 3 :

                                                    http://web.alfredstate.edu/faculty/weimandn/miscellaneous/atmega_miscellane
                                                    ous/ATmega Memory Map(b).gif

 L2 Informatique - 2018                  Thomas Quiniou                                                                       36
Le µcontrôleur ATMEGA328P

•    Flash : Peu coûteuse cette mémoire sert à stocker les programmes à exécuter, c’est une
     mémoire qui perdure après arrêt de l’alimentation. Rapide, elle est donnée pour une capacité de
     1 000 000 de cycles. L’atmega 328 en est doté de 32 kilos (d’où la référence 32..8)

                                             •   0x3FFF (base 16) ⇒ 16384 emplacements (en base 10)
                                             •   Chaque emplacement correspond à 16 bits (D0 à D15)
                                             •   On a donc 16384X16, soit 262144 bits au total
                                             •   Un octet étant codé sur 8 bits, on a donc 32768 octets
                                             •   1ko = 1024 ⇒ 32768/1024 = 32 ko

    L2 Informatique - 2018                  Thomas Quiniou                                       37
Le µcontrôleur ATMEGA328P
•     SRAM (Static Read Access Memory) : Coûteuse mais rapide, cette mémoire sert à stocker des
      données temporaires (les variables de votre programme par exemple). C’est une mémoire
      volatile. Votre Arduino Uno en possède seulement 2kilos, c’est peu et c’est probablement de là
      que naîtrons vos premiers soucis de mémoire…    (PROGMEM : Page 347 de la datasheet)

                                                                                             (Remarque : offset de 20 sur les adresses)

    Lorsque l’on programme en assembleur, voire même en C, on doit connaitre les adresses et le rôle
    des registres. On devra en effet positionner à 0 ou 1 tout ou partie des bits des registres liés à
    l’action à réaliser. Par exemple, si on veut actionner le port B, il faudra renseigner les registres
    PINB, DDRB et PORTB. Nous y reviendrons mais le langage Arduino permet, grâce à des fonctions
    haut niveau, de programmer sans devoir nécessairement rentrer dans les détails des registres.
    L2 Informatique - 2018                    Thomas Quiniou                                                                    38
Le µcontrôleur ATMEGA328P
•    EEPROM (Electrically-Erasable Programmable Read-Only Memory ou mémoire morte effaçable
     électriquement et programmable) : Elle permet le stockage par votre programme de données
     persistantes, peut coûteuse, mais lente, l’atmega 328 en possède 1 kilo-octet. Cette mémoire
     s’use plus rapidement, sa capacité est de 100 000 cycles d’écriture. Cette mémoire permettra à
     vos programmes de stocker des données de log ou des états devant être conserver de manière
     pérenne (après arrêt de l’alimentation).   Cf : https://www.arduino.cc/en/Reference/EEPROM

    L2 Informatique - 2018                  Thomas Quiniou                                        39
Les bases de l’électronique
  https://fr.flossmanuals.net/arduino/les-bases-de-lelectronique/

Avant d’aller plus loin dans la description des entrées/sorties de votre carte Arduino, il est
nécessaire de faire un court rappel des bases en électronique. Vous allez utiliser des composants
et des capteurs que vous allez relier à votre carte Arduino,

Électricité (Wikipedia):

L’électricité est l'effet du déplacement de particules chargées, à
l’intérieur d'un « conducteur », sous l'effet d'une différence de
potentiel aux extrémités de ce conducteur. Ce phénomène
physique est présent dans de nombreux contextes : l'électricité
constitue aussi bien l'influx nerveux des êtres vivants que les
éclairs d'un orage. Elle est largement utilisée dans les sociétés
développées pour transporter de grandes quantités d'énergie
facilement utilisable.

 L2 Informatique - 2018                                             Thomas Quiniou            40
Les bases de l’électronique
Tension : La tension a pour unité le Volt (V). La tension se mesure avec un voltmètre, entre 2
bornes d'un appareil électrique (en parallèle ou dérivation).
Courant : Le courant électrique a pour unité l'Ampère (A). Il se mesure avec un ampèremètre en
insérant l'appareil de mesure dans le circuit électrique (en série).

Analogie avec un remonte pente

 •   La piste de ski représente le circuit électrique fermé (en
     forme de boucle).

 •   Les skieurs représentent les charges électriques.

 •   Le remonte pente représente la pile.

 •   Le nombre de skieurs qui passe la ligne d'arrivée par
     seconde représente le courant électrique

 •   La différence de hauteur entre le bas et le haut de la
     piste représente la tension.

                                     http://physique.chimie.29.free.fr/cinquieme/electricite/tension_courant/tension_courant.htm

 L2 Informatique - 2018                           Thomas Quiniou                                                          41
Les bases de l’électronique
                                 Quelques composants
La résistance :
Une résistance R est un composant dont la principale caractéristique est d'opposer une
plus ou moins grande résistance (mesurée en ohms) à la circulation du courant électrique.
La tension U et le courant I sont reliés par la loi d’Ohm : U = R × I. Cette loi signifie que
lorsqu’une résistance est parcourue par un courant, une différence de potentiel s’établit
entre ses bornes.

Une résistance est un dipôle qui n’a pas de sens de branchement, vous pouvez
donc inverser les broches.

                                                                                           triangle URI

   Comment évaluer la résistance ?

   • Avec un ohmmètre

   • Grâce au code couleur

 L2 Informatique - 2018                           Thomas Quiniou                                          42
Les bases de l’électronique
Le condensateur :                                        Par Eric Schrader from San Francisco, CA, United States — 12739s, CC
                                                         BY-SA 2.0, https://commons.wikimedia.org/w/index.php?curid=37625896

Le condensateur est un composant électronique élémentaire, constitué de deux
armatures conductrices (appelées « électrodes ») en influence totale et séparées
par un isolant polarisable (ou « diélectrique »). Sa propriété principale est de
pouvoir stocker des charges électriques opposées sur ses armatures. La relation
caractéristique d'un condensateur idéal est :

C est la capacité électrique du condensateur, exprimée en farads (symbole : F).

Il existe différents types de condensateurs, certains sont polarisés (condensateurs chimiques, attention au sens),
d’autres non (condensateur céramiques).
                                                                               Alimentation        Condensateurs de découplage
                                                                               constante + bruit   des alimentations
Les condensateurs sont utilisés principalement pour :

• stabiliser une alimentation électrique (il se décharge lors des chutes
   de tension et se charge lors des pics de tension) ;
• traiter des signaux périodiques (filtrage…) ;
• séparer le courant alternatif du courant continu, ce dernier étant
   bloqué par le condensateur (si u est constant ⇒ du/dt = 0 ⇒ i=0);
• stocker de l'énergie, auquel cas on parle de supercondensateur.

 L2 Informatique - 2018                           Thomas Quiniou                                                       43
Les bases de l’électronique
La bobine (self en anglais)
Une bobine, solénoïde, auto-inductance ou quelquefois self (par anglicisme), est un composant courant en
électrotechnique et électronique. Une bobine est constituée d'un enroulement de fil conducteur éventuellement
autour d'un noyau en matériau ferromagnétique qui peut être un assemblage de feuilles de tôle ou un bloc de
ferrite. Les physiciens et ingénieurs français l'appellent souvent par synecdoque « inductance », ce terme
désignant la propriété caractéristique de la bobine, qui est son opposition à la variation du courant dans ses spires.
La relation caractéristique d'une bobine idéale est :

L est l’inductance électrique de la bobine, exprimée en henry (symbole : H).

Votre kit contient un relais électromécanique (KY-019, page 90 de la datasheet). Un relais est constitué d’un
électroaimant (bobine entourant un noyau) qui permet l’ouverture ou la fermeture d’un circuit secondaire. La
bobine emmagasine de l’énergie lorsqu’elle est alimentée, elle la restitue lorsque l’on coupe son alimentation (cf.
formule). Si rien n’est fait pour protéger le circuit, la surtension engendrée peut l’endommager, il faut donc
prendre quelques précautions. Le module KY-019 contient tous les éléments nécessaires, nous y reviendrons plus
tard.

 L2 Informatique - 2018                           Thomas Quiniou                                                   44
Les bases de l’électronique
La diode et la diode électroluminescente (DEL ou LED en anglais)
La diode un dipôle qui ne laisse passer le courant électrique que dans un sens. Une diode électroluminescente est
une diode qui en plus s’allume lorsqu’un courant la traverse.

                        Diode

                           Vseuil ≈ 0,7V

                        DEL

 L2 Informatique - 2018                            Thomas Quiniou                                             45
Les bases de l’électronique
      http://henrysbench.capnfatz.com/henrys-bench/arduino-output-devices/5mm-led-basics-and-the-arduino-quick-facts/
La diode électroluminescente et Arduino
                                          2. Calcul de la valeur de la résistance :
                       1. Circuit
                                          1.     Déterminer la tension de seuil de la diode (cf datasheet). Pour une LED rouge, elle est
                                                 d’environ 1,8V
                                          2.     Déterminer la tension à l’état haut d’une broche numérique. Avec une carte Arduino UNO,
                                                 elle est de 5V
                                          3.     Soustraire la tension de seuil de la diode à la tension du circuit : 5 - 1,8 = 3,2. Cette tension
                                                 correspond à la tension aux bornes de la résistance.
                                          4.     Déterminer le courant directe de la diode : 20 mA. Attention, ce courant doit être inférieur
                                                 au courant maximal délivré par la broche de l’Arduino (sortie numérique).
                                          5.     Déterminer la valeur de la résistance à partir de la loi d’Ohm : R = U / I = 3,2 / 0,02 = 160 Ω
                                                             ⇒ Prendre une valeur de résistance normalisée égale ou supérieure à 160 Ω

                                                                              4. Code
                3. Câblage

                                          >160
                                          ohms

 L2 Informatique - 2018                                Thomas Quiniou                                                                  46
Les bases de l’électronique
                             http://www.locoduino.org/spip.php?article122
Le bouton poussoir
Nous avons vu avec la diode comment utiliser une sortie numérique en activant celle-ci à l’état haut ou bas grâce à
la commande digitalWrite(pin, état). Le bouton poussoir va nous permettre de voir les entrées numériques et la
commande digitalRead(pin). La broche étant utilisée en entrée et non plus en sortie, il faudra l’indiquer dans votre
code à l’aide de la commande pinMode(pin, INPUT). La broche ne va donc plus piloter un courant, mais être à
l'écoute du courant en entrée. Un bouton poussoir est un interrupteur ouvert au repos et fermé lorsqu’il est
pressé (ou inversement).

         Peut-on brancher directement le bouton poussoir sur une entrée numérique?

                                          Vous ne risquez pas d’endommager la carte mais votre montage ne
                                          fonctionnera pas comme prévu :
                                          • Lorsque le bouton est pressé, l’entrée 2 est relié au +5V ⇒ OK
                                          • Lorsque le bouton est relâché, l’entrée 2 est « en l’air », elle peut prendre
                                             n’importe quelle valeur or on souhaiterait qu’elle soit à 0V ⇒ NOK

                                          Pour information, cela est dû au fait que les entrées sont en « haute
                                          impédance » (Hi-Z).

                                          Pour remédier à cette situation, on va rajouter une résistance de pull-down
                                          (résistance de tirage vers le bas) ou de pull-up (résistance de tirage vers le
                                          haut).

 L2 Informatique - 2018                            Thomas Quiniou                                                 47
Les bases de l’électronique
                Résistance de pull-down                                          Résistance de pull-up

                                                      Logique inverse

• Lorsque le bouton est pressé, l’entrée 2 est relié            • Lorsque le bouton est pressé, l’entrée 2 est reliée
  directement au +5V (état haut) et la résistance R est            directement à la masse (état bas) et la résistance de
  parcourue par un courant de 5V/R ; si vous prenez une            pull-down est parcourue par un courant de 5V/R.
  résistance de 4,7 kΩ, le courant sera de 1,1 mA.              • Lorsque le bouton est relâché, l’entrée 2 est relié au
• Lorsque le bouton est relâché, l’entrée 2 est reliée à           +5V (état haut) et aucun courant ne traverse la
  la masse via la résistance de pull-down (état bas) et            résistance.
  aucun courant ne traverse la résistance.

   L2 Informatique - 2018                            Thomas Quiniou                                                  48
Les bases de l’électronique
Le bouton poussoir, suite

Les résistances pull up sont très communes en électronique numérique, raison
pour laquelle le microcontrôleur qui équipe l’Arduino dispose de résistances de
pull up internes qui évitent l’utilisation de résistances externes. Ces
résistances internes ont une valeur comprise entre 20 et 50 Kilo-Ohm, certes
plus élevée que la valeur recommandée pour une résistance externe, mais
suffisante. Le schéma ci-après illustre le câblage du bouton poussoir sans
résistance de pull-up externe, la résistance de pull-up interne étant
représentée en traitillé et à l’intérieur de la carte Arduino.

Pour activer la résistance pull up interne d’une entrée, par exemple la no 2, il suffit d’écrire, dans la fonction setup :
pinMode (2, INPUT_PULLUP); à la place de : pinMode (2, INPUT);

Remarque : lorsque l’on presse ou relâche un bouton poussoir, il n’est pas rare que des rebonds (passages rapides
haut/bas) se produisent. Il est possible de filtrer ces rebonds en :
       • rajoutant un condensateur (env. 10 nF) en // sur le bouton poussoir
       • ou en testant dans le code l'état de l'entrée à deux reprises en peut de temps afin d'être sur que le
         bouton poussoir est vraiment appuyé (voir par exemple : https://learn.adafruit.com/tilt-sensor/using-a-tilt-sensor).

  L2 Informatique - 2018                               Thomas Quiniou                                                           49
Les bases de l’électronique
Le bouton poussoir, suite

Votre kit contient un module KY-004 équipé d’un bouton poussoir et d’une résistance de pull-up de 10kΩ (entre
l’entrée V+ et la sortie Signal).

                                                                     https://arduinomodules.info/ky-004-key-switch-module/

Exercice : câbler ce module sur l’entrée numérique 10 et écrire le code qui permet d’allumer ou d’éteindre une LED
en fonction de la position du bouton poussoir.

  L2 Informatique - 2018                         Thomas Quiniou                                                    50
Les bases de l’électronique
                                Quelques montages de base en électronique
Le pont diviseur de tension
Le diviseur de tension est un montage très classique et utile qui permet de diviser une tension d'entrée avec
seulement deux résistances. Imaginez que vous deviez mesurer une tension qui peut aller de 0 à 10V avec un
Arduino. Vous allez pour cela utiliser une entrée analogique (A0 par exemple) mais celle-ci ne peut mesurer que des
courant inférieurs à 5V. Il faut donc réduire la tension d’entrée afin de s’assurer qu’elle ne dépasse pas 5V faute
de quoi vous risquez d’endommager votre carte.

                            L’objectif est de calculer la valeur de R2 afin d’obtenir une tension U2 ≤ 5V quelque soit la
                            tension d’entrée. Il faut donc isoler R2 dans la formule du pont diviseur de tension :
                                  U2×(R1 + R2) = U×R2 ⇒ U2×R1 + U2× R2 = U×R2 ⇒ U2×R1 = U×R2 - U2× R2
                                  ⇒ U2×R1 = R2×(U - U2) ⇒ R2 = R1×U2/(U - U2)
                            Si vous choisissez par exemple une résistance R1 = 1kΩ, vous obtiendrez :
                                  R2 = 1000×5/(10 - 5) = 1000Ω = 1kΩ

                            Remarque : l’entrée du convertisseur est, pour faire simple, schématisé par la résistance
                            RL sur le circuit. Sa valeur est de plusieurs dizaines de Mégohms (typ. 100). Afin de ne pas
                            perturber le circuit, il faut prendre des valeurs de R1 et de R2 petites par rapport à RL. On
                            a pris dans l’exemple 1kΩ pour R1 mais on aurait pu prendre une valeur encore plus faible,
                            par exemple 100Ω. La contrepartie est que le courant consommé I sera beaucoup plus
                            important car I = U / (R1+R2).

 L2 Informatique - 2018                           Thomas Quiniou                                                     51
Les bases de l’électronique
                                 Quelques montages de base en électronique
Potentiomètres et rhéostats (https://fr.wikipedia.org/wiki/Potentiomètre)
Un potentiomètre (appelé familièrement potard) est un type de résistance variable à trois bornes, dont une est
reliée à un curseur se déplaçant sur une piste résistante terminée par les deux autres bornes. Ce système permet
de recueillir, entre la borne reliée au curseur et une des deux autres bornes, une tension qui dépend de la position
du curseur et de la tension à laquelle est soumise la résistance (cf pont diviseur de tension).

                              10V             Lorsque le curseur se déplace en les points A et B, le potentiel au point C
                                              varie entre le potentiel au point A (0V par exemple) et le potentiel au
                                              point B (10V par exemple). Le potentiomètre est donc un pont diviseur
                                              dont les résistances internes varient selon la position du curseur (mais
                               0V             R1+R2 reste constant)

                                                                   Un rhéostat est une résistance variable. Il est
                                                                   possible d’obtenir une résistance variable en reliant
                                                                   l’une   des   extrémités   (B   par   exemple)   d’un
                                                                   potentiomètre au curseur (C). Dans ce cas, on dit
                                                                   que la résistance R2 est court-circuitée.

 L2 Informatique - 2018                            Thomas Quiniou                                                   52
Les bases de l’électronique
                                     Quelques montages de base en électronique
Câblage d’un relais
Si vous devez piloter un module qui consomme du courant (un moteur par exemple), vous ne pourrez pas le brancher
directement sur une sortie de l’Arduino car celle-ci ne peut délivrer qu’au plus 20mA. Une solution est d’utiliser un
relais qui servira d’interrupteur (moteur ON ou OFF).

Le relais change d’état lorsque la bobine est traversée par un
courant.   Là   non   plus,   vous    ne   pourrez   pas   brancher
directement votre Arduino sur la bobine du relais. Il faudra
utiliser un transistor (par exemple 2N2222) qui est un
composant à 3 broches (b = base, e = émetteur, c= collecteur).
Lorsque la sortie de l’Arduino (Digital Pin sur le schéma) est à
l’état bas, le transistor fonctionne comme un interrupteur
ouvert et aucun courant ne traverse la bobine. Lorsqu’elle est
à l’état haut, l’interrupteur est fermé, un courant le traverse
(entre c et e) et le moteur tourne. Dans cette configuration,
un transistor fonctionne comme un robinet ouvert ou fermé, la
base b correspondant à la poignée de commande.
La diode D1 (par exemple 1N4004) est une diode dite de roue                                Attention, cette partie du
                                                                                           schéma est fausse voire
libre. Elle permet d’éviter d’endommager le transistor lorsque
                                                                                           dangereuse. Une idée?
l’on coupe l’alimentation de la bobine.

 L2 Informatique - 2018                              Thomas Quiniou                                               53
Les bases de l’électronique
                                                           Les entrées analogiques (CAN)

               Un convertisseur analogique-numérique (CAN, parfois convertisseur A/N, ou en anglais ADC pour Analog to Digital
               Converter ou plus simplement A/D) est un montage électronique dont la fonction est de traduire une grandeur
               analogique en une valeur numérique (codée sur plusieurs bits).              http://lewebpedagogique.com/physiris/2018/01/31/29604/

                L’Arduino UNO possède 6 entrées analogiques, numérotées de A0
                à A5, reliées à un convertisseur analogique/numérique qui renvoie
210-1 = 1023

                un code numérique sur 10 bits, soit une valeur comprise entre 0 et
                1023. La pleine échelle est de 5V, c'est à dire que la valeur
                numérique 0 correspond à 0V et la valeur numérique 1023
                correspond à 5V. Ainsi le pas de quantification est de 5V/1024 soit
                environ 5 mV.

                http://hebergement.u-psud.fr/villemejane/eiti/index.php/2017/09/16/arduino-entrees-analogiques/

                Initialisation d'une entrée analogique
                Les entrées analogiques A0 à A5 sont automatiquement paramétrées au démarrage du programme. Il n'y a donc rien
                à faire pour spécifier leur utilisation.

                L2 Informatique - 2018                               Thomas Quiniou                                                       54
Les bases de l’électronique
                                       Les entrées analogiques (CAN)
Lecture d'une entrée analogique
Pour pouvoir lire une entrée analogique, il vous faudra utiliser la fonction analogRead(pin) où pin correspond au
numéro de la broche que l'on souhaite lire : A0 à A5.

Afin de mettre en œuvre cette entrée analogique, nous allons utiliser un potentiomètre dont le curseur sera relié à
l’entrée A0. En fonction de la position du curseur et en modifiant/complétant le code ci-dessous, vous afficherez
la tension lue.

                                        Remarque     :   il   existe   une    fonction    de    mappage     bien    pratique
                                        https://www.arduino.cc/reference/en/language/functions/math/map/
                                        A voir aussi : https://openclassrooms.com/courses/programmez-vos-premiers-montages-
                                        avec-arduino/utilisez-les-potentiometres-les-entrees-analogiques-et-la-fonction-de-
                                        mappage
 L2 Informatique - 2018                          Thomas Quiniou                                                         55
Les bases de l’électronique
  http://www.locoduino.org/spip.php?article4
  http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.ApprendrePWM

                                            Pulse Width Modulation (PWM)
Jusqu’à présent, nous avons vu l’émission de signaux numériques par le biais des broches numériques et de la
fonction digitalWrite(...) afin d’allumer et d’éteindre une DEL. Ces signaux numériques ont soit une valeur égale à
LOW, c’est à dire 0V, soit une valeur égale à HIGH, ce qui correspond à la tension d’alimentation de l’Arduino, VDD,
soit 5V pour les Arduino à base de micro-contrôleurs AVR.

Mais les sorties numériques ne nous permettent pas, par exemple, de régler la luminosité de la DEL, ou de faire
varier la vitesse de rotation d’un moteur. Pour pouvoir faire cela, il serait nécessaire de pouvoir disposer de sorties
permettant des tensions intermédiaires entre LOW et HIGH (conversion numérique/analogique).

Mais ceci n’existe pas sur les Arduino à base d’AVR. L’alternative est d’utiliser une PWM, pour Pulse Width
Modulation, ou MLI en français pour Modulation de largeur d’impulsion.

Qu’est ce que la PWM ?

On reste en numérique, les signaux ont toujours une valeur LOW ou HIGH et le principe est de construire un signal
qui est alternativement LOW et HIGH et de répéter très vite cette alternance. La DEL est donc alternativement
allumée et éteinte mais le cycle est tellement rapide que la persistance rétinienne nous donne l’illusion d’une DEL
allumée en permanence.

 L2 Informatique - 2018                                 Thomas Quiniou                                              56
Les bases de l’électronique
                Pulse Width Modulation (PWM)
•        Prenons par exemple une période de 10ms, soit une
         fréquence de 100Hz. Si la DEL est allumée pendant
         5ms et éteinte pendant 5ms, comme sur la figure ci-
         dessous, l’impression sera une luminosité de 50% de
         la luminosité maximum.

    •     Si la DEL est allumée pendant 1ms et éteinte pendant
          9ms, l’impression sera une luminosité de 10% comme
          sur la figure ci-dessous.

         Le pourcentage de temps passé à l’état HIGH sur la période du signal est appelé le rapport cyclique. Il varie donc
         de 0%, le signal est tout le temps LOW, à 100%, le signal est tout le temps HIGH.

         La fréquence de la PWM est prédéterminée sur l’Arduino. Il est possible de la changer mais ce n’est pas une
         possibilité accessible très simplement. La fréquence n’est pas la même selon les broches. Sur le Uno, la fréquence
         est de 490Hz sur les broches 3, 9, 10 et 11 et de 980Hz sur les broches 5 et 6.

        L2 Informatique - 2018                         Thomas Quiniou                                                 57
Les bases de l’électronique
                                         Pulse Width Modulation (PWM)

Mise en œuvre :
Nous allons mettre en œuvre la PWM avec une simple DEL. Mais contrairement au montage page 46, nous n’allons
pas utiliser la broche 2 mais la 3 qui est une broche PWM.

En ce qui concerne la programmation, la fonction permettant
de fixer le rapport cyclique de la PWM est la fonction
analogWrite(...). Nom bien mal choisi puisque, comme on l’a
vu,   tout   est   numérique.   Le    premier   argument     de
analogWrite(...) est la broche concernée et le second
argument le rapport cyclique. Le rapport cyclique n’est pas
donné de 0 à 100 mais de 0 à 255. Il faut donc faire une
règle de 3 pour calculer la valeur à appliquer pour le rapport
cyclique voulu. Par exemple, la valeur à appliquer pour un
rapport cyclique de 75% sera égal à 0,75 x 255 = 191.

Remarque : vous pouvez aussi utiliser la fonction MAP

  L2 Informatique - 2018                          Thomas Quiniou                                         58
Les bases de l’électronique
                                      Pulse Width Modulation (PWM)

Voici pour commencer un programme très simple qui augmente
progressivement, de 1 en 1, la luminosité de la DEL de 0,
extinction totale, à 255, luminosité maximum, puis recommence
à 0. On va fixer le temps de ce cycle à 1000ms. Le délai entre
chaque augmentation est donc de 1000 / 255 = 3,922 ms.
Arrondissons à 4ms. En utilisant un byte pour stocker la valeur,
nous pouvons profiter du débordement qui se produit lorsque,
étant à 255, l’ajout de 1 fait repasser la valeur 0. Voir à ce
propos « Types, constantes et variables ». Vous noterez
également qu’il n’est pas nécessaire de programmer la broche en
sortie pour son utilisation en tant que sortie PWM. Cette
programmation s’effectue automatiquement lors du premier
analogWrite(). Malgré tout il faut que la fonction setup() soit
présente même si elle est vide.

Exercice : proposez un circuit, et le code Arduino correspondant, qui permet de modifier la luminosité d’une
LED en fonction de la position d’un potentiomètre.

L2 Informatique - 2018                          Thomas Quiniou                                                 59
Vous pouvez aussi lire