microc:gpio [WEBGE Wikis]

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" focusable="false" width="1em" height="1em" preserveAspectRatio="xMidYMid meet" viewBox="0 0 24 24" class="iconify mr-1" data-icon="mdi:arrow-left" style="vertical-align: -0.125em; transform: rotate(360deg);"><path d="M20 11v2H8l5.5 5.5l-1.42 1.42L4.16 12l7.92-7.92L13.5 5.5L8 11h12z" fill="currentColor"></path></svg>[[microc:accueilmc|{{ :iconemaison.jpg?nolink&30|Sommaire Microcontrôleurs}}]]

===== Microcontrôleurs - Entrées, sorties (GPIO) =====
{{ :microc:microcontroleur.png?nolink|}}

[Mise à jour le : 19/2/2025] <html><span style="color:red">En cours de rédaction</span></html>

  * **Source**
    * <html><a href="https://www.arduino.cc/en/hardware" target="_blank">Arduino</a></html>
    * <html><a href="https://www.raspberrypi.com/products/" target="_blank">Raspberry Pi pico</a></html>
    * <html><a href="https://www.espressif.com/en/products/socs/esp32" target="_blank">esp32</a></html>
 
<callout type="primary" icon="true" title="CARTES DE TEST">Les exemples de code de cette page ont été testés sur une [[microc:uc:uno|Arduino Uno]], une [[microc:uc:mkr|Arduino MKR Wifi 1010]], une [[microc:uc:esp32|ESP32 Feather Huzzah]] et sur une  [[microc:uc:rp2|Raspberry Pi Pico]].</callout>

 ==== 1. Généralités ====
  * Vidéo : <html><a href="https://www.youtube.com/watch?v=U9T0fjFyVow" target="_blank">Microcontrôleur : Comment ça marche ? - SILIS Electronique</a></html> \\

« //D'un point de vue fonctionnel, dans un système à base de **microcontrôleur((Un microcontrôleur est un circuit intégré qui rassemble les éléments essentiels d'un ordinateur : processeur, mémoires, unités périphériques et interfaces d'entrées-sorties.))**, on appelle **entrées-sorties** les échanges d'informations entre le processeur et les périphériques qui lui sont associés. De la sorte, le système peut réagir à des modifications de son environnement, voire le contrôler. Les entrées, sorties sont parfois désignées par l'acronyme **I**/**O**, issu de l'anglais **I**nput/**O**utput ou encore **E**/**S** pour **E**ntrées/**S**orties.// » <html><a href="https://fr.wikipedia.org/wiki/Microcontr%C3%B4leur" target="_blank" title="Microcontrôleur">Wikipédia</a></html>

{{ :microc:systememicroproc.png?nolink |}}

<callout type="tip" icon="true" title="GPIO">«// D'un point de vue matériel, un **microcontrôleur** dispose de **broches((Une broche de microcontrôleur est un élément physique situé sur le boîtier du microcontrôleur, qui permet de connecter ce dernier à d'autres composants électroniques, tels que des capteurs, des actionneurs ou d'autres circuits.))** pouvant être contrôlées par un logiciel. Elles peuvent se comporter comme des entrées ou des sorties, d'où le nom "Entrée / Sortie à usage général", ou **GPIO** (**G**eneral **P**urpose **I**nput **O**utput. Le nombre de broches d’un microcontrôleur étant limité, il est fréquent d’avoir **plusieurs fonctionnalités sur une même broche**.// » <html><a href="https://fr.wikipedia.org/wiki/General_Purpose_Input/Output" target="_blank">Wikipédia</a></html>
</callout>

=== 1.1 Exemples de microcontrôleurs === 

<nav type="pills">
  * [[#tab-atmega328p|ATMEGA328P]]
  * [[#tab-rp2040_1|RP2040]]
  * [[#tab-rp2050_1|RP2050]]
  * [[#tab-esp32_1|esp32]]

<pane id="tab-atmega328p">
  * <html><a href="https://www.microchip.com/en-us/product/atmega328p" target="_blank"><b>Documentation</b></a></html> sur le site **Microchip**.
</pane>

<pane id="tab-rp2040_1">
  * <html><a href="https://www.raspberrypi.com/products/rp2040/" target="_blank"><b>Documentation</b></a></html> sur le site **Raspberry Pi**.
</pane>

<pane id="tab-rp2050_1">
  * <html><a href="https://www.raspberrypi.com/products/rp2050/" target="_blank"><b>Documentation</b></a></html> sur le site **Raspberry Pi**.
</pane>

<pane id="tab-esp32_1">
  * <html><a href="https://www.espressif.com/en/products/socs/esp32" target="_blank"><b>Documentation</b></a></html> sur le site **ESP32**.
</pane>
</nav>

\\

=== 1.2 Cartes de prototypage ===
<nav type="pills">
  * [[#tab-unor3_1|Arduino UNO R3]]
  * [[#tab-rpipico|Rpi pico & picoW]]
  * [[#tab-rpipico2|Rpi pico 2 & pico2W]]
  * [[#tab-esp32_2|ESP32]]

<pane id="tab-unor3_1">
  * <html><a href="https://www.arduino.cc/en/hardware"><b>Documentation</b></a></html> sur le site Arduino.

  * Les broches du microcontrôleur sont reliées électriquement aux broches des connecteurs de la carte. Un <html><a href="https://www.locoduino.org/IMG/png/pinoutuno.png" target="blank"><b>SYNOPTIQUE</b></a></html> identifie ces liens. \\  __Exemple__ : on voit sur ce schéma que la broche 19 du microcontrôleur est reliée avec la broche 13 du connecteur de la carte. \\ \\ <color #ed1c24>**ATTENTION**</color> : dans l'environnement de programmation Arduino, le programme fait référence à la connectique de la carte et non à celle du microcontrôleur ! 
</pane>

<pane id="tab-rpipico">
  * <html><a href="https://www.raspberrypi.com/products/raspberry-pi-pico/"><b>Documentation</b></a></html> sur le site **Raspberry Pi**.
</pane>

<pane id="tab-rpipico2">
  * <html><a href="https://www.raspberrypi.com/products/raspberry-pi-pico-2/"><b>Documentation</b></a></html> sur le site **Raspberry Pi**.
</pane>

<pane id="tab-esp32_2">
A faire
</pane>
</nav>

\\

==== 2. Entrées, sorties numériques ====
=== 2.1 Généralités ===
Pour éviter de faire référence à des valeurs électriques (tension ou intensité), on définit souvent l’état d’un signal numérique en utilisant la logique booléenne.  \\
- **true** (« **1** » logique ou **HIGH**)  \\
- **false** (« **0** » logique ou **LOW**) . \\ \\

<nav type="pills">
  * [[#tab-atmega328p_2|ATMEGA328P]]
  * [[#tab-rp2040_2|RP2040]]
  * [[#tab-rp2050_2|RP2050]]

<pane id="tab-atmega328p_2">
  * (Vcc = 5V - 25°C) \\

^ Niveau logique  ^ Signal de sortie (Output)             ^ Signal d'entrée (Input)  ^
^ LOW             | 0V à 0,5V (**VoL**)((Tension de sortie à l'état bas )) pour  0 à 20mA  (IoL) | 0V à 2,2V (**Vil**((Tension d'entrée à l'état bas)))          |
^ HIGH            | 4,5V à 5V (**VoH**)((Tension de sortie à l'état haut)) pour   0 à 20mA (IoH) | 2,7V à 5V (**ViH**((Tension d'entrée à l'état haut)))    | 

<callout type="danger" title="LIMITES A RESPECTER" color="red" icon="true">Le courant maximum en sortie sur une broche ne doit pas dépasser **40mA**. Au total, il ne doit pas dépasser **200mA**.</callout>
</pane>

<pane id="tab-rp2040_2">
  * A rédiger
</pane>

<pane id="tab-rp2050_2">
  * A rédiger
</pane>
</nav>
\\
=== 2.2 Sortie numérique ===
== 2.2.1 Généralités ==
Lorsqu'une broche est configurée en **sortie numérique**, le microcontrôleur délivre des **signaux logiques** “**0**”(LOW) ou “**1**"(HIGH).

<callout type="warning" color="red" icon="true" title="PRECAUTIONS D'UTILISATION">
Une sortie numériqque est fragile. Ne **JAMAIS** la relier à un générateur \\ Une sortie numérique délivre **très peu de puissance** (quelques centaines de mW). Il n’est donc pas possible de la relier directement à un actionneur (moteur). Il est nécessaire de placer une interface de puissance (hacheur, relais) entre elle et l’actionneur à commander.</callout>
{{ :tinyclros:gpio:sortienum.png?nolink |}}

{{ :materiels:capteurs:environnement:code.png?nolink|}}
== 2.2.2 Programmation ==
Les programmes suivants sont codés :
  * En langage **C** sur Arduino Uno ou compatible
  * En langage **MicroPython** sur Raspberry Pi Pico et ESP32

<nav type="pills">
  * [[#tab-unor3_3|Arduino UNO R3]]
  * [[#tab-rpipico_3|Rpi pico & picoW]]
  * [[#tab-esp32_3|ESP32]]

<pane id="tab-unor3_3">
{{ :arduino:arduino.png?nolink&60|}}
  * //a. Présentation// \\ Toutes les broches d'E/S de la carte Arduino Uno peuvent servir d'entrées, sorties numériques. Cela inclut les broches numérotées entre **0** et **13**, mais aussi les broches **A0** à** A5**. Le symbole **~** identifie les broches capables de délivrer un signal numérique **PWM** (**P**ulse **W**ith **M**odulation).

{{ :microc:unogpio.png?nolink |}}

<callout type="primary" icon="true" title="SCHEMA DE LA CARTE">Téléchargeable <html><a href="http://marcusjenkins.com/wp-content/uploads/2014/06/ARDUINO_V2.pdf" target="_blank" title="pdf">ici</a></html>.</callout>

  * //b. Configuration d'une broche en sortie// \\
    * **Ressource** : <html><a href="https://www.arduino.cc/reference/en/language/functions/digital-io/pinmode/" target="_blank">pinMode()</a></html> sur le site <html><a href="https://www.arduino.cc/" target="_blank">arduino.cc</a></html>

<callout type="tip" icon="true" title="CONFIGURATION">**Configurer** une broche signifie qu'on précise qu'elle doit se comporter soit comme une entrée d'information, soit comme une **sortie d'information**.</callout>

<code cpp *.cpp>
// Exemple 1 
// -------------------------------------------------------------------------------------------------------------------------------
// Les instructions contenues dans la fonction setup() s'exécutent une fois
void setup() {
  pinMode(12,OUTPUT); // Associé à OUTPUT pinMode force la broche 12 de la carte Arduino Uno à se comporter comme une sortie
}

// Exemple 2
// -------------------------------------------------------------------------------------------------------------------------------
// L'utilisation de la directive "define" améliore la lisibilité des programmes
#define led 12

void setup() {
  pinMode(led,OUTPUT); // On précise que la broche 12 de la carte Arduino Uno se comporte comme une sortie et est connectée à une LED
}
</code>

  * //c. Ecriture d'un état logique sur une broche// \\
    * **Ressource** : <html><a href="https://www.arduino.cc/reference/en/language/functions/digital-io/digitalwrite/" target="_blank">digitalWrite()</a></html> sur le site <html><a href="https://www.arduino.cc/" target="_blank">arduino.cc</a></html>

<callout type="tip" icon="true" title="ECRITURE">Un état logique **haut(HIGH)** ou **bas(LOW)** peut être **écrit** sur une broche préalablement configurée en sortie.</callout>

<code cpp *.cpp>
// Exemple 1 
// -------------------------------------------------------------------------------------------------------------------------------
// Les instructions contenues dans la fonction setup() s'exécutent une fois
void setup() {
  pinMode(12,OUTPUT);     // Associé à OUTPUT pinMode force la broche 12 de la carte Arduino Uno à se comporter comme une sortie
}

// Les instructions contenues dans la fonction loop() s'exécutent tant que le microcontrôleur est sous tension
void loop() {
   digitalWrite(12, HIGH); // La broche 12 présente un état logique haut (par exemple 5V) 
}

//Exemple 2
// -------------------------------------------------------------------------------------------------------------------------------
// L'utilisation de la directive define améliore la lisibilité des programmes
#define led 12

void setup() {
  pinMode(led,OUTPUT);
}

void loop() {
   digitalWrite(led, HIGH); // On applique un état logique haut (par exemple 5V)  à la LED => elle s'éclaire
}
</code>

{{ :microc:wokwiled.png?nolink&350|}}
//d. Synthèse: blink//
<code cpp *.cpp>
// Faire clignoter une led connectée à la broche 12 de la carte Arduino Uno
// Matériels : Carte Arduino, led, résistance
// IDE: Arduino 2.x.x
// Fichier : blink.ino

#define led 12
 
void setup() {
  pinMode(led,OUTPUT); 
 }
 
void loop() {
   digitalWrite(led, HIGH);
   delay(500); // Attente 0,5s
   digitalWrite(led, LOW);
   delay(500); // Attente 0,5s
}
</code>
</pane>

<pane id="tab-rpipico_3">
  * //a. Présentation// \\ La majeure partie des broches du Raspberry Pi Pico sont des GPIO nommées « GPxx » ci-dessous. 

{{ :python:micropython:raspipico.jpg?nolink&900 |}}

  * //b. Configuration d'une broche en sortie// \\
    * **Ressources** sur Micropython.org.
      * <html><a href="https://docs.micropython.org/en/latest/library/machine.html?highlight=machine#module-machine" target="_blank">module machine</a></html> | <html><a href="https://docs.micropython.org/en/latest/library/machine.Pin.html" target="_blank">class Pin – control I/O pins</a></html>

<callout type="tip" icon="true">**Configurer** une broche signifie qu'on précise qu'elle doit se comporter soit comme une entrée d'information, soit comme une sortie d'information.</callout>

<code Python *.py>
# Exemples
from machine import Pin # Bibliothèque nécessaire aux E/S

# Exemple 1 : configuration en sortie de la broche 15 connectée à une led
led = Pin(15,Pin.OUT) # Associée à Pin.OUT, Pin force la broche 15 de la carte Rpi Pico à se comporter comme une sortie
# ou
led = Pin(Pin.board.GP15,Pin.OUT) # pour plus de clarté

# Exemple 2 : configuration en sortie de la broche associée à la led de la carte
led_carte = Pin('LED',Pin.OUT) # 'LED' <=> 25 (GPIO25) # Associée à Pin.OUT, Pin force la broche 25 de la carte Rpi Pico 
                                                       # à se comporter comme une sortie
</code>

  * //c. Ecriture d'un état logique sur une broche// \\
    * **Ressources** sur Micropython.org.
      * <html><a href="https://docs.micropython.org/en/latest/library/machine.html?highlight=machine#module-machine" target="_blank">module machine</a></html> | <html><a href="https://docs.micropython.org/en/latest/library/machine.Pin.html" target="_blank">class Pin – control I/O pins</a></html>

<code Python *.py>
from machine import Pin # Bibliothèque

# Configuration de la broche associée à la led de la carte
led_carte = Pin('LED',Pin.OUT) # 'LED' <=> 25 (GPIO25)

# Exemples
# Ecriture d'un "1" sur GPIO25 -> la LED s'éclaire
led_carte.on()
# Ecriture d'un "0" sur GPIO25 -> la LED s'éteint
led_carte.off()
</code>

  * d. // Synthèse: Blink.py// \\
    * **Ressources** sur Micropython.org.
      * <html><a href="https://docs.micropython.org/en/latest/library/machine.html?highlight=machine#module-machine" target="_blank">module machine</a></html> | <html><a href="https://docs.micropython.org/en/latest/library/time.html?highlight=time#module-time" target="_blank">module time</a></html> | <html><a href="https://docs.micropython.org/en/latest/library/machine.Pin.html" target="_blank">class Pin – control I/O pins</a></html>
      * <html><a href="https://docs.micropython.org/en/latest/rp2/quickref.html#pins-and-gpio" target="_blank">Quick reference for the Rp2, Pins and GPIO</a></html>.

{{ :microc:wokrp2led.png?nolink&240|}}
<code Python blink.py>
# -------------------------------------------------------------------------------
# Faire clignoter une led externe à la carte Raspberry Pi Pico
# Matériels : Raspberry Pi Pico, led, Shield Grove
# IDE : Thonny
# Fichier : blink.py
# -------------------------------------------------------------------------------
# Bibliothèques
from machine import Pin
import time
 
# Configuration de la broche associée à la led de la carte
led = Pin(Pin.board.GP15,Pin.OUT) # (GPIO15)
 
while (True):
    led.on()
    time.sleep(0.5) # Attente 0,5s
    led.off()
    time.sleep(0.5) # Attente 0,5s
</code>
</pane>

<pane id="tab-esp32_3">
  * //a. Présentation// \\
La majeure partie des broches du Raspberry Pi Pico sont des GPIO.
 
{{ :microc:adafruit_huzzah_32_pinout.png?nolink&800 |}}

  * //b. Configuration d'une broche en sortie// \\
    * **Ressources** sur MicroPython.org 
      * <html><a href="https://docs.micropython.org/en/latest/library/machine.html?highlight=machine#module-machine" target="_blank">module machine</a></html> | <html><a href="https://docs.micropython.org/en/latest/library/machine.Pin.html" target="_blank">class Pin – control I/O pins</a></html>

<code Python *.py>
# Exemple
from machine import Pin # Bibliothèque nécessaire aux E/S

# Configuration en sortie de la broche associée à la led de la carte
led_carte = Pin(13,Pin.OUT) # Associée à Pin.OUT, Pin force la broche 13 de la carte ESP32 
                            # à se comporter comme une sortie
</code>

  * //c. Ecriture d'un état logique sur une broche// \\
    * **Ressources** sur Micropython.org.
      * <html><a href="https://docs.micropython.org/en/latest/library/machine.html?highlight=machine#module-machine" target="_blank">module machine</a></html> | <html><a href="https://docs.micropython.org/en/latest/library/machine.Pin.html" target="_blank">class Pin – control I/O pins</a></html>

<code Python *.py>
from machine import Pin # Bibliothèque nécessaire aux E/S

# Configuration en sortie de la broche associée à la led de la carte
led_carte = Pin(13,Pin.OUT) # Associée à Pin.OUT, Pin force la broche 13 de la carte ESP32
                            # à se comporter comme une sortie

# Exemples
# Ecriture d'un "1" sur GPIO13 -> la LED s'éclaire
led_carte.on()
# Ecriture d'un "0" sur GPIO13 -> la LED s'éteint
led_carte.off()
</code>

  * //d. Synthèse: Blink.py// \\
    * **Ressources** sur Micropython.org.
      * <html><a href="https://docs.micropython.org/en/latest/library/machine.html?highlight=machine#module-machine" target="_blank">module machine</a></html> | <html><a href="https://docs.micropython.org/en/latest/library/time.html?highlight=time#module-time" target="_blank">module time</a></html> | <html><a href="https://docs.micropython.org/en/latest/library/machine.Pin.html" target="_blank">class Pin – control I/O pins</a></html>
      * <html><a href="https://docs.micropython.org/en/latest/esp32/quickref.html#pins-and-gpio" target="_blank">Quick reference for the ESP32, Pins and GPIO</a></html>.

<code python blink.py>
# -------------------------------------------------------------------------------
# Faire clignoter la led de la carte ESP32 Feather Huzzah
# IDE : Thonny
# Fichier : blink.py
# -------------------------------------------------------------------------------
# Bibliothèques
from machine import Pin
import time

# Configuration de la broche associée à la led de la carte
led_carte = Pin(13, Pin.OUT)

while (True):
    led_carte.on()
    time.sleep(1) # Attente 1s
    led_carte.off()
    time.sleep(1) # Attente 1s
</code>
</pane>
</nav>

\\

=== 2.3 Sortie numérique (PWM) ===
== 2.3.1 Généralités ==
La **M**odulation de **L**argeur d'**I**mpulsions (**MLI** ; en anglais **PWM** pour **P**ulse **W**idth **M**odulation), est une technique couramment utilisée pour synthétiser des signaux **pseudo** analogiques à l'aide de circuits numériques ("**1**" ou "**0**"). \\ 
Le PWM est utilisé par exemple pour contrôler la luminosité d'une LED, changer la couleur d'une LED RGB ou encore piloter la vitesse d'un moteur. \\ \\
Le principe est de créer un signal prenant les valeurs "**1**" ou "**0**", à fréquence fixe mais dont le rapport cyclique est contrôlé numériquement, la **valeur moyenne** de ce signal étant une grandeur analogique, égale au produit du rapport cyclique par l'amplitude maximale du signal. <html><a href="https://fr.wikipedia.org/wiki/Modulation_de_largeur_d%27impulsion" target="_blank">Wikipédia</a></html>
{{ :microc:signalpwm.png?nolink |}}

{{ :materiels:capteurs:environnement:code.png?nolink|}}
== 2.3.2 Programmation ==
Les programmes suivant sont codés :
  * En langage **C** sur Arduino Uno ou compatible
  * En langage **MicroPython** sur Raspberry Pi Pico et ESP32

<nav type="pills">
  * [[#tab-unor3_4|Arduino UNO R3]]
  * [[#tab-rpipico_4|Rpi pico & picoW]]
  * [[#tab-esp32_4|ESP32]]

<pane id="tab-unor3_4">
  * **Ressource** : <html><a href="https://www.arduino.cc/reference/en/language/functions/analog-io/analogwrite/" target="_blank">analogWrite()</a></html> sur le site <html><a href="https://www.arduino.cc/" target="_blank">arduino.cc</a></html>

{{ :arduino:arduino.png?nolink&60|}}
  * //a. Présentation// \\ 

^  Cartes  ^  Broche PWM  ^  Fréquence  ^  Repérage de la broche PWM sur la carte  ^ \\
|Uno, Nano, Mini|3, 5, 6, 9, 10, 11|490 Hz (broches 5 et 6: 980 Hz)| ~ |

{{ :arduino:esnum.png?nolink |}}

<callout type="primary" icon="true" title="SCHEMA DE LA CARTE">Téléchargeable <html><a href="http://marcusjenkins.com/wp-content/uploads/2014/06/ARDUINO_V2.pdf" target="_blank" title="pdf">ici</a></html>.</callout>

  * //b. Configuration d'une broche en sortie et génération d'un signal PWM //
<code cpp *.cpp>
// Exemple
// --------------------------------------------------------
// Diminution de la luminosité d'une led avec un signal PWM

#define led 11

// Les instructions contenues dans la fonction setup() s'exécutent une fois
void setup() {
  pinMode(led, OUTPUT);    // Associé à OUTPUT pinMode force la broche 11 de la carte Arduino Uno à se comporter comme une sortie
}

// Les instructions contenues dans la fonction loop() s'exécutent tant que le microcontrôleur est sous tension
void loop() {
   analogWrite(led, 127); // La broche 11 délivre un signal PWM de fréquence F=490Hz 
                          // et de rapport cyclique = 1/2 (voir la ressource pour le calcul du rapport cyclique)
}
</code>
</pane>

<pane id="tab-rpipico_4">
  * <html><span style="color:red">A faire</a></html>
</pane>

<pane id="tab-esp32_4">
  * <html><span style="color:red">A faire</a></html> \\
Ressource provisoire <html><a href="https://randomnerdtutorials.com/esp32-esp8266-pwm-micropython/" target="_blank">ESP32/ESP8266 PWM with MicroPython – Dim LED</a></html>
</pane>
</nav>

\\

=== 2.4 Entrée numérique ===
== 2.4.1 Généralités ==
Lorsqu'une broche est configurée en **entrée numérique**, le microcontrôleur est capable de traiter des signaux prenant la valeur logique "**0**" ou "**1**".

<callout type="warning" icon="true" title="RESISTANCE DE RAPPEL">
Les microcontrôleurs disposent de **résistances de rappel** internes pouvant être connectées par le logiciel. \\ Une entrée numérique utilisée dans un programme **ne doit pas être laissée "en l’air"** (non connectée) car elle prendra alors un état logique aléatoirement et le comportement du programme deviendra imprévisible.</callout>

__Exemple__ : détermination de l'état ouvert ou fermé d'un bouton-poussoir.

{{ :tinyclros:gpio:resistancerappel.jpg?nolink&600 |}}

<callout type="warning" color="red" icon="true" title="PRECAUTIONS D'UTILISATION">Les entrées numériques sont **fragiles**. Elles ne supportent ni les **décharges électrostatiques** ni les **surtensions**. Il ne faut ni les toucher ni leur appliquer une tension supérieure à 5V ou inférieure à 0V.</callout>

{{ :materiels:capteurs:environnement:code.png?nolink|}}
== 2.4.2 Programmation ==
Les programmes suivant sont codés :
  * En langage **C** sur Arduino Uno ou compatible
  * En langage **MicroPython** sur Raspberry Pi Pico et ESP32

<nav type="pills">
  * [[#tab-unor3_5|Arduino UNO R3]]
  * [[#tab-rpipico_5|Rpi pico & picoW]]
  * [[#tab-esp32_5|ESP32]]

<pane id="tab-unor3_5">
  * //a. Présentation// \\ Toutes les broches d'E/S de la carte Arduino Uno peuvent servir d'entrées, sorties numériques. Cela inclut les broches numérotées entre **0** et **13**, mais aussi les broches **A0** à** A5**. Le symbole **~** identifie les broches capables de délivrer un signal numérique **PWM** (**P**ulse **W**ith **M**odulation). \\ \\

{{ :microc:unogpio.png?nolink |}}

<callout type="primary" icon="true" title="SCHEMA DE LA CARTE">Téléchargeable <html><a href="http://marcusjenkins.com/wp-content/uploads/2014/06/ARDUINO_V2.pdf" target="_blank" title="pdf">ici</a></html>.</callout>


  * //b. Configuration d'une broche en entrée// \\
    * **Ressource** : <html><a href="https://www.arduino.cc/reference/en/language/functions/digital-io/pinmode/" target="_blank">pinMode()</a></html> sur le site <html><a href="https://www.arduino.cc/" target="_blank">arduino.cc</a></html>

<callout type="tip" icon="true" title="CONFIGURATION">**Configurer** une broche signifie qu'on précise qu'elle doit se comporter soit comme une **entrée d'information**, soit comme une sortie d'information.</callout>

{{ :microc:led2.png?nolink&250|Exemples 1 & 2}}
<code cpp *.cpp>
// Exemple 1 : connexion d'une broche à un bouton-poussoir via une résistance pull-down
// externe à la carte Arduino Uno (celle-ci n'en dispose pas en interne!).
// ------------------------------------------------------------------------------------------
// Les instructions contenues dans la fonction setup() s'exécutent une fois
void setup() {
  pinMode(2,INPUT);     // Associé à INPUT pinMode force la broche 2 de la carte Arduino Uno 
                        // à se comporter comme une entrée
                        // Optionnel si la broche n'a pas été préalablement
                        // configurée en sortie, car c'est le mode par défaut
}
// ------------------------------------------------------------------------------------------
// Exemple 2
// ------------------------------------------------------------------------------------------
// L'utilisation de la directive "define" améliore la lisibilité des programmes
#define BP 2

void setup() {
  pinMode(BP,INPUT); // On précise que la broche 2 de la carte Arduino Uno se comporte comme 
                     // une entrée et est connectée à un bouton-poussoir
                     // optionnel si la broche n'a pas été préalablement
                     // configurée en sortie, car c'est le mode par défaut
}
</code>

{{ :microc:led3.png?nolink&250|Exemple 3}}
<code cpp *.cpp>
// Exemple 3 : connexion d'une broche à un bouton-poussoir via la résistance de pull-pup interne
// de la carte arduino uno. On économise ainsi 1 composant
// ---------------------------------------------------------------------------------------------
// L'utilisation de la directive "define" améliore la lisibilité des programmes
#define BP 2

void setup() {
  pinMode(BP, INPUT_PULLUP);; // On précise que la broche 2 de la carte Arduino Uno est connectée à la  
                              // résistance de pull-up interne, se comporte comme une entrée et est 
                              // connectée à un bouton-poussoir
}
</code>

//c. Lecture de l'état logique sur une broche// \\
  * **Ressource** : <html><a href="https://www.arduino.cc/reference/en/language/functions/digital-io/digitalread/" target="_blank">digitalRead()</a></html> sur le site <html><a href="https://www.arduino.cc/" target="_blank">arduino.cc</a></html>

<callout type="tip" icon="true" title="LECTURE">Un état logique **haut(HIGH)** ou **bas(LOW)** peut être **lu** sur une broche préalablement configurée en entrée.</callout>

<code cpp *.cpp>
// Exemple 1 
// -------------------------------------------------------------------------------------------------------------------------------
// Les instructions contenues dans la fonction setup() s'exécutent une fois
void setup() {
  pinMode(2,INPUT);     // Associé à INPUT pinMode force la broche 2 de la carte Arduino Uno à se comporter comme une entrée
                        // ou pinMode(2, INPUT_PULLUP); selon le montage utilisé
}

// Les instructions contenues dans la fonction loop() s'exécutent tant que le microcontrôleur est sous tension
void loop() {
   bool etat_bp = digitalRead(2); // L'état logique sur l'entrée 2 est transféré dans une variable de type booléen 
}

//Exemple 2
// -------------------------------------------------------------------------------------------------------------------------------
// L'utilisation de la directive define améliore la lisibilité des programmes
#define bp 2

void setup() {
  pinMode(bp,INPUT); // ou pinMode(bp, INPUT_PULLUP); selon le montage utilisé
}

void loop() {
   bool etat_bp = digitalRead(bp);  // L'état logique sur l'entrée 2 est transféré dans une variable de type booléen, cette entrée
                                    // est reliée à un bouton-poussoir
}
</code>  

{{ :microc:led3b.png?nolink&300|}}
//d. Synthèse: ledbp//
<code cpp *.cpp>
// Titre : LED_BP
// Description : la led s’éclaire lorsqu’on presse le bouton-poussoir (BP), elle s’éteint lorsqu’on le relâche.

// Entrées, sorties
#define led 12
#define bp 2

bool etat_bp;

void setup() {   // Configuration des E/S
  pinMode(led, OUTPUT);
  pinMode(bp, INPUT_PULLUP);
}

void loop() {
  // Lecture de l’entrée
  bool etat_bp = !(digitalRead(bp)); // le bouton-poussoir étant actif à l'état bas "0" alors que la led l'est à l'état haut "1"
                                     // nécessite d'inverser l'état logique de la variable etat_bp
  digitalWrite(led,etat_bp);         // Ecriture de l’entrée sur la sortie
}
</code>
</pane>

<pane id="tab-rpipico_5">
  * **Ressources** sur Micropython.org.
    * <html><a href="https://docs.micropython.org/en/latest/library/machine.html?highlight=machine#module-machine" target="_blank">module machine</a></html> | <html><a href="https://docs.micropython.org/en/latest/library/time.html?highlight=time#module-time" target="_blank">module time</a></html> | <html><a href="https://docs.micropython.org/en/latest/library/machine.Pin.html" target="_blank">class Pin – control I/O pins</a></html>
    * <html><a href="https://docs.micropython.org/en/latest/rp2/quickref.html#pins-and-gpio" target="_blank">Quick reference for the RP2, Pins and GPIO </a></html>

  * //b. Configuration d'une broche en en entrée// \\

  * //c. Lecture de l'état logique sur une broche// \\

  * //d. Synthèse: ?.cpp//

//Exemple de code pour un **Raspberry Pi Pico**//
<code Python *.py>
# Configuration (en entrée) des broches connectées à deux boutons-poussoirs
# Bibliothèques à installer
from machine import Pin
 
# Configuration (en entrée) des broches connectées à deux boutons-poussoirs
button_min = Pin(20, Pin.IN)
button_hr = Pin(21, Pin.IN)
...
</code>
</pane>

<pane id="tab-esp32_5">
  * **Ressources** sur Micropython.org.
    * <html><a href="https://docs.micropython.org/en/latest/library/machine.html?highlight=machine#module-machine" target="_blank">module machine</a></html> | <html><a href="https://docs.micropython.org/en/latest/library/time.html?highlight=time#module-time" target="_blank">module time</a></html> | <html><a href="https://docs.micropython.org/en/latest/library/machine.Pin.html" target="_blank">class Pin – control I/O pins</a></html>
    * <html><a href="https://docs.micropython.org/en/latest/esp32/quickref.html#pins-and-gpio" target="_blank">Quick reference for the ESP32, Pins and GPIO</a></html>

  * //b. Configuration d'une broche en en entrée// \\
  * //c. Lecture de l'état logique sur une broche// \\
  * //d. Synthèse: ?.cpp//
//Exemple de code pour un **ESP32 Feather Huzzah**//
<code python *.py>
# Configuration (en entrée) des broches connectées à deux boutons-poussoirs
button_min = Pin(25, Pin.IN)
button_hr = Pin(26, Pin.IN)
...
</code>
</pane>
</nav>

\\

{{ :python:micropython:deroulement_interruption.gif?nolink&280|}}
=== 2.5 Entrée d'interruption ===

== 2.5.1 Généralités ==
Une **interruption** est un **arrêt temporaire** de l'exécution normale d'un programme par le processeur afin d'exécuter un autre programme (appelé **service d'interruption**). \\
L’interruption est provoquée par une cause externe (action sur un bouton-poussoir, mesure réalisée par un capteur, horloge temps réel, etc.). \\
On utilise les interruptions afin de permettre des **communications non bloquantes** avec des périphériques externes. \\
Une interruption tient compte de l’état logique présent sur une broche. Couramment, on la déclenchera sur **le front montant, le front descendant, ou chacun des fronts** d’un signal logique.

<callout type="warning" icon="true">
Une interruption sera reconnue si le signal présente des fronts "propres". Il faudra donc s’assurer de la qualité du signal.
Les figures ci-dessous représentent un signal transmis à la fermeture du contact d’un anémomètre. Le signal de gauche n’est pas utilisable à cause du rebondissement du contact. En effet, il contient quatre fronts montants au lieu d’un seul comme dans le cas du signal de droite.</callout>

{{ :tinyclros:gpio:antirebong.png?nolink |}}

{{ :materiels:capteurs:environnement:code.png?nolink|}}
== 2.5.2 Programmation ==
Les programmes suivant sont codés :
  * En langage **C** sur Arduino Uno ou compatible
  * En langage **MicroPython** sur Raspberry Pi Pico et ESP32
<tabs>
  * [[#tab-uno_4|Arduino Uno]]
  * [[#tab-pico_4|RPi Pico]]
  * [[#tab-esp32_4|ESP32]]

<pane id="tab-uno_4">
  * **Ressource** : 
//a. Présentation// \\
//b. Configuration d'une broche en entrée d'interruption// \\
//c. Evènement et gestionnaire d'interruption// \\
//d. Synthèse: ?//
</pane>

<pane id="tab-pico_4">
  * **Ressource** : 
//a. Présentation// \\
//b. Configuration d'une broche en entrée d'interruption// \\
//c. Evènement et gestionnaire d'interruption// \\
//d. Synthèse: ?//
</pane>

<pane id="tab-esp32_4">
{{ :python:micropython:pmod_btn_25707.png?nolink&90|Digilent Pmod BTN: 4 User Pushbuttons}}
  * **Ressource** :  <html><a href="https://docs.micropython.org/en/latest/esp8266/tutorial/pins.html?highlight=interrupt" target="_blank"><strong>Quick reference for ESP32</strong>, GPIO Pins, External interrupts</a></html> sur Micropython.org.

//a. Présentation// \\
  * <html><span style="color:red">Ressource provisoire</span> <a href="https://randomnerdtutorials.com/micropython-interrupts-esp32-esp8266/" target="_blank">MicroPython: Interrupts with ESP32 and ESP8266</a></html> 

//b. Configuration d'une broche en entrée d'interruption// \\

//c. Evènement et gestionnaire d'interruption// \\

//d. Synthèse: HORLOGE NUMERIQUE// \\
  * **Matériel** : [[microc:uc:esp32|ESP32 Feather Huzzah]], <html><a href="https://fr.rs-online.com/web/p/modules-de-developpement-d-interface-homme-machine-ihm/1368059/" target="_blank" title="Distributeur">Digilent Pmod BTN: 4 User Pushbuttons</a> </html> <html><a href="https://reference.digilentinc.com/_media/reference/pmod/pmodbtn/pmodbtn_sch.pdf" target="_blank">[Schéma]</a></html>

{{ :python:micropython:youtube.png?nolink&50|}}
  * **Description** : l'extrait du programme HORLOGE ci-dessous illustre l'utilisation d'interruptions assurant le réglage de l'heure à l'aide de trois boutons-poussoir. Une vidéo de présentation est accessible  <html><a href="https://youtu.be/FGXCdyn_A9A" target="_blank">ici</a></html>.

<code python *.py>
# -----------------------------------------------
# Code partiel du programme HORLOGE
# -----------------------------------------------

# Réglage de l'heure à la mise sous tension 
time_offset=12*3600+0*60+0 # hh+mm+ss

# Routines de service d'interruption (ISR)
def handle_interrupt_min(pin):
    global time_offset
    time_offset+=60
    time.sleep(.2)

def handle_interrupt_hr(pin):
    global time_offset
    time_offset+=3600
    time.sleep(.2)

# Réglage des minutes
# Ajout de 60s à l'heure initiale
button_min = Pin(25, Pin.IN)
# Gestionnaire d'interruption
button_min.irq(trigger=Pin.IRQ_RISING,handler=handle_interrupt_min)

# Réglage des heures
# Ajout de 3600s à l'heure initiale
button_hr = Pin(26, Pin.IN)
# Gestionnaire d'interruption
button_hr.irq(trigger=Pin.IRQ_RISING,handler=handle_interrupt_hr)
{{ :python:micropython:materiel:thonny.png?nolink&70|}}
</code>

<callout type="tip" icon="true" title="TELECHARGER">Le projet  <html><strong><a href="https://webge.fr/doc/wikis/code/micropython/MICROPYTHON_ESP32_HORLOGE.zip" target="_blank">MICROPYTHON_ESP32_HORLOGE</a></strong></html> pour l'IDE <html><a href="https://thonny.org/" target="_blank">Thonny</a></html>. </callout>
</pane>
</tabs>

\\

==== 3. Entrées analogiques ====
  * **Ressource** : <html><a href="https://www.arduino.cc/reference/en/language/functions/analog-io/analogread/" target="_blank">site Arduino</a></html>
=== 3.1 Généralités ===

{{ :materiels:capteurs:environnement:code.png?nolink|}}
=== 3.2 Programmation ===
<tabs>
  * [[#tab-uno_5|Arduino Uno]]
  * [[#tab-pico_5|RPi Pico]]
  * [[#tab-esp32_5|ESP32]]

<pane id="tab-uno_5">
//a. Présentation// \\
//b. Configuration d'une broche en entrée analogique// \\
//c. Lecture d'une entrée analogique// \\
//d. Synthèse: ?//
</pane>

<pane id="tab-pico_5">
//a. Présentation// \\
//b. Configuration d'une broche en entrée analogique// \\
//c. Lecture d'une entrée analogique// \\

{{ :materiels:capteurs:potentiometre.png?nolink&80|Potentiomètre}}
//d. Synthèse: ?//
  * **Ressource** 
    * <html><a href="https://docs.micropython.org/en/latest/esp32/quickref.html#adc-analog-to-digital-conversion" target="_blank">ADC (analog to digital conversion)</a></html> | <html><a href="https://docs.micropython.org/en/latest/library/machine.Pin.html" target="_blank">class Pin – control I/O pins</a></html> sur Micropython.org.

//Exemple de code pour un **Raspberry Pi Pico**//
<code python *.py>
# -------------------------------------------------------------------------------
# Lecture et affichage dans la console de la tension issue d'un potentiomètre 
# Date : 22/5/2023
# Matériels : Raspberry Pi Pico, Shield Grove, pot. 10k
# ADC accessibles sur le shield Grove pour RP2 :
# Connecteur: ADC      : GPIO
#        A0 : ADC0     : 26
#        A1 : ADC0,ADC1: 26,27
#        A2 : ADC1,ADC2: 27,28
# IDE : Thonny
# -------------------------------------------------------------------------------
from machine import ADC, Pin
import time

# Le potentiomètre 10kOhm est connecté à l'entrée analogique A0 du shield.
# Attention : La tension doit être comprise entre 0 - 3,3V (3,6V max !)
# sur une entrée analogique.
# Configuration
pot = ADC(Pin(26)) 

while (True):
    val=pot.read_u16() # lecture de l'ADC
    U = val*3.3/65535 # Calcul de la tension
    print("%.2f" % U) # Affichage dans la console (formaté à 2 décimales)
    time.sleep(1)
</code>
</pane>

<pane id="tab-esp32_5">
//a. Présentation// \\
<html><span style="color:red">Ressource provisoire</span></html> : <html><a href="https://randomnerdtutorials.com/esp32-esp8266-analog-readings-micropython/" target="_blank">ESP32/ESP8266 Analog Readings with MicroPython</a></html> \\

//b. Configuration d'une broche en entrée analogique// \\

//c. Lecture d'une entrée analogique// \\

{{ :materiels:capteurs:potentiometre.png?nolink&80|Potentiomètre}}
//d. Synthèse: ?//
  * **Ressource** 
    * <html><a href="https://docs.micropython.org/en/latest/esp32/quickref.html#adc-analog-to-digital-conversion" target="_blank">ADC (analog to digital conversion)</a></html> sur Micropython.org.
//Exemple de code pour un **ESP32 Feather Huzzah**//
<code python *.py>
# ADC accessibles en Python sur la carte ESP32 Feather Huzzah :
# ADC:GPIO
# A2 : 34
# A3 : 39
# A4 : 36
# A7 : 32
# A9 : 33

from machine import ADC, Pin

# Le potentiomètre 10kOhm est connecté à l'entrée analogique A2 de l'ESP32.
# Configuration
adc = ADC(Pin(34)) 
# Sur une entrée analogique, la tension doit
# être comprise entre 0 - 3,3V (3,6V max !)
adc.atten(ADC.ATTN_11DB) # voir doc
# Mesure
value = adc.read()

print(value) # affichage dans la console
</code>
</pane>

</tabs>

\\

==== pour aller plus loin ====
**SISEL SA** - <html><a href="http://www.didel.com/LogiqueMicro.pdf" target="_blank" title="pdf">Entrées-sorties d’un microcontrôleur </a></html>