microc:micropython:tuto1gpio [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.
[[microc:accueilmc|{{ :iconemaison.jpg?nolink&30|Sommaire Microcontrôleur}}]]

===== Tutoriel "Etape par Etape" - Premiers programmes en MicroPython ou CircuitPython avec une carte Raspbery Pi Pico W =====
{{ :python:micropython:micropycircuipy.png?nolink|}}

[Mise à jour le :19/8/2023] 

  * **Ressources**
    * <html><a href="https://micropython.org/" target="_blank">MicroPython.org</a></html>
    * <html><a href="https://docs.micropython.org/en/latest/index.html#" target="_blank">MicroPython documentation</a></html>
    * <html><a href="https://datasheets.raspberrypi.com/pico/raspberry-pi-pico-python-sdk.pdf" target="_blank">Datasheet Raspberry Pi Pico Python SDK</a></html>
    * <html><a href="https://thonny.org/" target="_blank">IDE Thonny</a></html>
    * <html><a href="https://how2electronics.com/getting-started-with-raspberry-pi-pico-w-using-micropython/" target="_blank">Getting Started with Raspberry Pi Pico W using MicroPython</a></html>

  * **Lectures connexes**
      * **Installer MicroPython** - [[microc:uc:espressif|MicroPython - Les modules Espressif ESP32 et ESP8266]]
      * **Raspberry Pi Pico** - [[:microc:uc:rp2|Les modules Raspberry Pi Pico et Pico W]]
      * **Programmez** ! Juillet/Août 2019 
      * **Elektor 489** Mai/Juin 2021

---- 

==== Préambule ====
Ce tutoriel a pour objectif de vous faire découvrir la programmation de la carte Raspberry Pi Pico en MicroPython ou CircuitPython à l'aide de l'éditeur Thonny. Après une description rapide du matériel, vous le connecterez à l'IDE Thonny afin de réaliser les programmes suivants : 
    * 1. **blink.py** - Commande d'une sortie numérique : faire clignoter la LED de la carte Raspberry Pi Pico !
    * 2. **angle** - Lecture d'une entrée analogique : afficher la position angulaire d'un axe (en °) 
    * 3. **afftemp.py** - Afficheur graphique : afficher la température délivrée par le capteur interne au microcontrôleur sur un afficheur graphique.
    * 4. **affbme280.py** - Afficheur graphique et capteur numérique : afficher la température, l'humidité et la pression ambiantes. 
    * 5. **afftsl2591** - Afficheur graphique et capteur numérique : afficher la luminosité ambiante.

==== 1. Le matériel ====
  * **Ressource**
    * Wiki [[:microc:uc:rp2|MicroPython - Les modules Raspberry Pi Pico et Pico W]]* 

==== 2. L'IDE Thonny ====
=== 2.1 Présentation ===
  * **Ressources**
    * <html><a href="https://thonny.org/" target="_blank">Site</a></html> du logiciel.
    * <html><a href="https://docs.micropython.org/en/latest/rp2/quickref.html"target="_blank">Quick reference for the RP2¶</a></html>
{{ :python:micropython:materiel:thonny.png?nolink&100|}}
L'<html><a href="https://www.redhat.com/fr/topics/middleware/what-is-ide" title="Environnement de développement" target="_blank">IDE</a></html> **Thonny** propose aux débutants un **environnement de programmation** intuitif pour **Python** (MicroPython, CircuitPython), aussi facile à déployer qu'à utiliser.
Dans un souci de simplicité, Thonny embarque la dernière version de Python qu'il installe en même temps que l'EDI. Le programme est par ailleurs préconfiguré afin d'éviter les difficultés liées au paramétrage de l'application. 

=== 2.2 Connexion de la carte Rp2 à l'IDE ===
<tabs>
  * [[#tab-micropy_1|MicroPython]]
  * [[#tab-circuitpy_1|CircuitPython]]
<pane id="tab-micropy_1">
  - **Brancher** la carte RP2((mnémonique pour Raspberry Pi Pico)) au PC avec le câble USB.
  - **Ouvrir** l'IDE Thonny {{ :python:micropython:thonny1.png?nolink |}}
  - Dans le menu, sélectionner **outils -> options... -> Interpréteur**. \\ Sélectionner l'interpréteur **MicroPython (Raspberry Pi Pico)** et le **port** sur lequel est connectée la carte (COM18 ci-dessous est un exemple, votre port peut être différent). {{ :python:micropython:thonny2.png?nolink |}}
  - Un message indiquant la **version de MicroPython** sur la carte doit apparaître dans la console comme dans l'exemple ci-dessous . \\ {{ :python:micropython:thonny3.png?nolink |}}
  - **Tester** la communication avec la carte en entrant print("hello") dans la console. {{ :python:micropython:thonny4.png?nolink |}}
</pane>
<pane id="tab-circuitpy_1">
  - **Brancher** la carte <html><span title="mnémonique pour Raspberry Pi Pico" style="cursor: pointer;">RP2</span><sup>2)</sup> au PC avec le câble USB</html>. Une fenêtre de l'explorateur de fichier s'ouvre comme ci dessous sur un nouveau lecteur USB appelé **CIRCUITPY**. \\ Ce lecteur est l'endroit où l'on dépose les fichiers contenant le code et les bibliothèques nécessaires au programme.{{ :python:micropython:circuitpy.jpg?nolink |}}
  - **Ouvrir** l'IDE Thonny {{ :python:micropython:thonny1.png?nolink |}}
  - Dans le menu, sélectionner **outils -> options... -> Interpréteur**. \\ Sélectionner l'interpréteur **CircuitPython (générique)** et le **port** sur lequel est connectée la carte (COM36 ci-dessous est un exemple, votre port peut être différent). {{ :python:micropython:thonny2b.png.jpg?nolink |}}
  - Un message indiquant la **version de CircuitPython** sur la carte doit apparaître dans la console comme dans l'exemple ci-dessous . \\ {{ :python:micropython:thonny3b.png?nolink |}}
  - **Tester** la communication avec la carte en entrant print("Hello") dans la console. {{ :python:micropython:thonny4.png?nolink |}}
</pane>
</tabs>

=== 2.3 Installation des bibliothèques sur la carte Rp2 ===
<tabs>
  * [[#tab-micropy_2|MicroPython]]
  * [[#tab-circuitpy_2|CircuitPython]]
<pane id="tab-micropy_2">
L'utilisation de certains capteurs, afficheur etc. avec le Raspberry Pi Pico nécessitent d'avoir préalablement installé des bibliothèques dans l'espace mémoire de la carte.  
\\ \\
**Exemple** : installation de la bibliothèque //**ssd1306.py**// nécessaire à l'afficheur graphique utilisé dans ce tutoriel.

  - **Sélectionner** l'icône **ouvrir...** (Ctrl+O) et choisir **Cet ordinateur** dans la boîte de dialogue.{{ :python:micropython:thonny5a.png?nolink |}}
  - Dans l'explorateur de fichiers, entrer le **chemin** précisé dans le paragraphe **Préparation** du **document réponse** et **ouvrir** //**ssd1306.py**// dans Thonny.
  - **Sauvegarder** le fichier dans la carte en suivant la démarche suivante : 
    - A partir du chemin **Fichier -> Enregistrer sous...**(Ctrl+Shift+S), sélectionner **Raspberry Pi Pico** {{ :python:micropython:thonny5b.png?nolink |}}
    - Ouvrir le dossier **lib** sur la carte et enregistrer le fichier avec le nom **//ssd1306.py//** {{ :python:micropython:thonny6.png?nolink |}}
  - Fermer le fichier **//ssd1306.py//** dans Thonny.
</pane>
<pane id="tab-circuitpy_2">
L'utilisation de certains capteurs, afficheur etc. avec le Raspberry Pi Pico nécessitent d'avoir préalablement installé des bibliothèques dans l'espace mémoire de la carte.
\\ \\
**Exemple** : installation de la bibliothèque //**ssd1306.py**// nécessaire à l'afficheur graphique.
  - **Ouvrir** une **nouvelle fenêtre** de l'explorateur de fichier et entrer le **chemin** précisé dans le paragraphe **Préparation** du **document réponse**. \\ Placer cette fenêtre avec celle de CIRCUITPY en côte à côte comme ci-dessous. Placer le fichier //ssd1306.py// dans **CIRCUITPY** par un glisser-déposer. {{ :python:micropython:libcircuitpy.png?nolink |}}
</pane>
</tabs>

==== 3. Programmation ====
=== 3.1 Programme 1 - Commande d'une sortie numérique ===
{{ :python:micropython:materiel:led.jpg?nolink&100|LED}}
<callout type="primary" title="Objectif" icon="true">Faire clignoter une LED externe à la carte Raspberry Pi Pico !</callout>

== 3.1.1 Généralités ==
« //Dans un système à base de **microcontrôleur**, on appelle **entrées-sorties** les échanges d'informations entre le processeur et les périphériques qui lui sont associés. Ainsi, le système peut réagir à des modifications de son environnement, voire le contrôler. Elles 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/General_Purpose_Input/Output" target="_blank">Wikipédia</a></html>

{{ :tinyclros:gpio:microcont.jpg?nolink&60|}}
<callout type="tip" icon="true">Un **microcontrôleur** dispose de broches 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. \\ 
\\
__Exemple__ : la **broche** (pin) 38 du microcontrôleur est reliée à la broche **31** de la carte RP2. C'est une entrée/sortie à usage général, identifiée par **GP26**. Elle peut être **configurée** comme une entrée analogique (**ADC0**),  une entrée/sortie numérique général ou I2C (**I2C1 SDA**). {{ :python:micropython:pinrp2_31.jpg?nolink&250 |}}
Le choix (configuration) est fait dans le logiciel. La **configuration** de la broche 38 du microcontrôleur en tant que sortie numérique s'écrit : 
 <color #ed1c24>Pin(26,Pin.OUT)</color> 
</callout>

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) correspondra par exemple à 5V ou 3,3V \\
- **false** (« 0 » logique) correspondra à 0V.

<callout type="danger" icon="true">
Une sortie numérique 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 |}}

== 3.1.2 Activités de programmation ==
<tabs>
  * [[#tab-micropy_3|MicroPython]]
  * [[#tab-circuitpy_3|CircuitPython]]
<pane id="tab-micropy_3">
  * **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>

  * **Etape 1** - Créer un nouveau programme
    - Cliquer sur l'icône **Nouveau** (Ctrl+N).
    - Copier-coller le code de l'exemple ci-dessous dans l'espace de travail de l'éditeur.

<code python blink.py>
# ---------------------------------------------------------------
# Exemple de code pour faire clignoter la led de la carte
# Matériels : Raspberry Pi Pico, Shield Grove
# Langage : MicroPython
# IDE : Thonny
# Source : blink.py
# ---------------------------------------------------------------
from machine import Pin
import time

# Configuration de l'entrée sortie connectée à la led de la carte
led = Pin('LED', Pin.OUT)  # 'LED' <=> 25 (GPIO25)

while (True):
    led.on()
    time.sleep(0.5)  # Attente 0,5s
    led.off()
    time.sleep(0.5)
</code>

  * **Etape 2** - Enregistrer le programme
    * Enregistrer le programme dans votre compte sur le serveur en le nommant comme ci-dessus.

  * **Etape 3** - Tester le programme
    * Exécutez le programme en cliquant sur {{:python:micropython:startcoderp2.jpg?nolink|}}.

<callout type="question" title="MODIFICATION du PROGRAMME 1" color="red" icon="true">Une led externe à la carte étant placée sur **GP16** (accessible sur le **connecteur D16** du Shield Groove), **modifier** le code de l'exemple de telle sorte que la led externe s'éclaire pendant 100ms toutes les secondes. \\ __Remarque__ : en MicroPython, le texte 'LED' de l'exemple doit être remplacé par le numéro de l'entrée/sortie à usage général. </callout>
</pane>

<pane id="tab-circuitpy_3">
  * **Ressources** sur docs.circuitpython.org.
    * <html><a href="https://docs.circuitpython.org/en/latest/shared-bindings/digitalio/index.html" target="_blank"><strong>digitalio</strong> - Basic digital pin support</a></html>

  * **Etape 1** - Créer un nouveau programme
    - Cliquer sur l'icône **Nouveau** (Ctrl+N)
    - Copier-coller le code de l'exemple ci-dessous dans l'espace de travail de l'éditeur.

<code python blink.py>
# ---------------------------------------------------------------
# Exemple de code pour faire clignoter la led de la carte
# Matériels : Raspberry Pi Pico, Shield Grove
# Langage : CircuitPython
# IDE : Thonny
# Source : blink.py
# ---------------------------------------------------------------
import board
import digitalio
import time

# Configuration de l'entrée sortie connectée à la led de la carte
led = digitalio.DigitalInOut(board.LED)
led.direction = digitalio.Direction.OUTPUT

while True:
    led.value = True
    time.sleep(0.5)  # Attente de 0,5s
    led.value = False
    time.sleep(0.5)
</code>

  * **Etape 2** - Enregistrer le programme
    * Enregistrer le programme avec le nom de l'exemple ci-dessus dans votre compte sur le serveur.

  * **Etape 3** - Tester le programme
    * Exécutez le script en cliquant sur {{:python:micropython:startcoderp2.jpg?nolink|}}.

<callout type="question" title="MODIFICATION du PROGRAMME 1" color="red" icon="true">Une led externe à la carte étant placée sur **GP16** (accessible sur le **connecteur D16** du Shield Groove), **modifier** le code de l'exemple de telle sorte que la led externe s'éclaire pendant 100ms toutes les secondes.  
\\ __Remarques__ : dans le langage CircuitPython, le texte //LED// de l'exemple doit être remplacé par l'entrée, sortie à usage général (GPIO) sur laquelle est connectée la led externe. La liste des GPIO connues de CircuitPython peut être visualisée dans la console avec la commande //dir(board)//. </callout>
</pane>
</tabs>

{{ :materiels:capteurs:potentiometre.png?nolink&80|Potentiomètre}}
=== 3.2 Programme 2 - Lecture d'une entrée analogique ===
<callout type="primary" title="Objectif" icon="true">Afficher la position angulaire (en °) d'un axe dans la console de l'IDE.</callout>

== 3.2.1 Matériels ==
    * **Capteur** : <html><a href="https://wiki.seeedstudio.com/Grove-Rotary_Angle_Sensor/" target="_blank">Rotary angle sensor Grove</a></html>

== 3.2.2 Généralités ==
    * <html><a href="https://zestedesavoir.com/tutoriels/686/arduino-premiers-pas-en-informatique-embarquee/745_les-grandeurs-analogiques/3430_les-entrees-analogiques-de-larduino/" target="_blank">Un signal analogique : petits rappels</a></html> sur le site Zeste de savoir.

== 3.2.3 Activités de programmation ==
<tabs>
  * [[#tab-micropy_4|MicroPython]]
  * [[#tab-circuitpy_4|CircuitPython]]

<pane id="tab-micropy_4">
  * **Ressources** sur Micropython.org.
    * <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/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>.

  * **Etape 1** - Créer un nouveau programme
    - Cliquer sur l'icône **Nouveau** (Ctrl+N).
    - Copier-coller le code de l'exemple ci-dessous dans l'espace de travail de l'éditeur.

<code python angle.py>
# -------------------------------------------------------------------------------
# Exemple de code pour afficher la valeur N délivrée par le  
# convertisseur analogique numérique ADC0
# Matériels : Raspberry Pi Pico, Shield Grove, potentiomètre 10k
# Langage : MicroPython
# IDE : Thonny
# Source : angle.py
# -------------------------------------------------------------------------------
# Identification des entrées analogiques disponibles sur le Shield Grove
# Shield    :         RP2040
#           : ADC       : GPIO
# -----------------------------------
#   A0      : ADC0      : GP26
#   A1      : ADC0,ADC1 : GP26, GP27
#   A2      : ADC1,ADC2 : GP27,GP28
# -------------------------------------------------------------------------------
from machine import ADC, Pin
import time
 
# Le potentiomètre 10k est connecté à l'entrée analogique A0 du shield.
pot = ADC(Pin(26))
 
while (True):
    # Lecture de la valeur délivrée par le convertisseur analogique numérique
    # N est un entier positif codé sur 16 bits
    N = pot.read_u16()
    print(f"N = {N}")  # Affichage dans la console
    time.sleep(1) # Attente 1s
</code>

  * **Etape 2** - Enregistrer le programme
    * Enregistrer le programme dans votre compte sur le serveur en le nommant comme ci-dessus.

  * **Etape 3** - Tester le programme
    * Exécutez le programme en cliquant sur {{:python:micropython:startcoderp2.jpg?nolink|}}.

<callout type="question" title="MODIFICATION du PROGRAMME 2" color="red" icon="true">Sachant que la tension Ve maximale à la sortie du potentiomètre est égale à **3,3V** lorsque l'angle maximum parcouru par son axe est **300°**, modifier l'exemple ci-dessus pour qu'il affiche la tension (en V) et l'angle (en °) dans la console de l'IDE. {{ :python:micropython:modelemesureangle.png?nolink&700 |}} \\ On considère que les différentes grandeurs sont proportionnelles entre elles. \\ __Exemple d'affichage attendu__ : **Ve = 1.2V** => **N=23909** => **Angle =  109,4°**. \\ __Remarque__ : arrondir les résultats à 1 décimale avec la fonction //round(valeur,1)// et utiliser une f-string pour l'affichage.
</callout>
</pane>

<pane id="tab-circuitpy_4">
  * **Ressources** sur docs.circuitpython.org.
    * <html><a href="https://docs.circuitpython.org/en/latest/shared-bindings/analogio/index.html" target="_blank">Module analogio</a></html>
    * <html><a href="https://docs.circuitpython.org/en/latest/shared-bindings/busio/index.html#busio.I2C" target="_blank">class busio.i2c</a></html>

  * **Etape 1** - Créer un nouveau programme
    - Cliquer sur l'icône **Nouveau** (Ctrl+N)
    - Copier-coller le code de l'exemple ci-dessous dans l'espace de travail de l'éditeur.

<code python angle.py>
# -------------------------------------------------------------------------------
# Exemple de code pour afficher la valeur N délivrée par le convertisseur
# analogique numérique ADC0.
# Matériels : Raspberry Pi Pico, Shield Grove, potentiomètre 10k
# Langage : CircuitPython
# IDE : Thonny
# Source : angle.py
# -------------------------------------------------------------------------------
# Identification des entrées analogiques disponibles sur le Shield Grove
# Shield    :         RP2040
#           : ADC       : GPIO
# -----------------------------------
#   A0      : ADC0      : GP26
#   A1      : ADC0,ADC1 : GP26, GP27
#   A2      : ADC1,ADC2 : GP27,GP28
# -------------------------------------------------------------------------------
import board
from analogio import AnalogIn
import time

# Le potentiomètre 10k est connecté à l'entrée analogique A0 du shield.
pot = AnalogIn(board.A0)

while (True):
    # Lecture de la valeur délivrée par le convertisseur analogique numérique
    # N est un entier positif codé sur 16 bits
    N = pot.value
    print(f"N = {N}")  # Affichage dans la console
    time.sleep(1)   # Attente 1s
</code>

  * **Etape 2** - Enregistrer le programme
    * Enregistrer le programme avec le nom de l'exemple ci-dessus dans votre compte sur le serveur.

  * **Etape 3** - Tester le programme
    * Exécutez le script en cliquant sur {{:python:micropython:startcoderp2.jpg?nolink|}}.

<callout type="question" title="MODIFICATION du PROGRAMME 2" color="red" icon="true">Sachant que la tension Ve maximale à la sortie du potentiomètre est égale à **3,3V** lorsque l'angle maximum parcouru par son axe est **300°**, modifier l'exemple ci-dessus pour qu'il affiche la tension (en V) et l'angle (en °) dans la console de l'IDE. {{ :python:micropython:modelemesureangle.png?nolink&700 |}} \\ On considère que les différentes grandeurs sont proportionnelles entre elles. \\ __Exemple d'affichage attendu__ : **Ve = 1.2V** => **N=23909** => **Angle =  109,4°**. \\ __Remarque__ : arrondir les résultats à 1 décimale avec la fonction //round(valeur,1)// et utiliser une f-string pour l'affichage.
</callout>
</pane>
</tabs>

{{ :arduino:gravity-i2c-oled-128x64-display.jpg?nolink&150|Gravity OLED-2864 Display}}
=== 3.3 Programme 3 - Afficheur graphique ===
<callout type="primary" title="Objectif" icon="true">Afficher la température délivrée par le **capteur interne** au microcontrôleur sur un afficheur graphique.</callout>

== 3.3.1 Matériels ==
    * **Afficheur graphique** : [[materiels:afficheurs:ard0_96|0,96" 128x64 OLED 2864 Display module - SSD1306 (I2C)]]

== 3.3.2 Généralités ==
Sur un écran, les **pixels** constituent une **image numérique**. On y accède par l'intermédiaire de leurs **coordonnées** **horizontales** (**X**) et **verticales** (**Y**). Le système de coordonnées place l'origine (0,0) dans le coin supérieur gauche de l'écran, avec X positif croissant vers la droite et Y positif croissant vers le bas. L'axe Y est inversé par rapport au repère cartésien utilisé en mathématiques, mais c'est une pratique établie dans de nombreux systèmes graphiques informatiques. Si nécessaire, l'affichage peut être pivoté.
{{ :arduino:adagfx1.jpg?500&nolink |}}

Les **coordonnées** sont **toujours exprimées en pixels**; il n'y a pas d'échelle implicite au monde réel exprimé en millimètres ou en pouces, la taille d'un dessin sera fonction de la densité, en pixels, de l'afficheur. Si vous visez une représentation du monde réel, vous aurez besoin de mettre vos coordonnées à l'échelle. Le pas des points peut être trouvé dans la fiche technique de l'écran, ou en mesurant sa largeur et en divisant le nombre de pixels par cette mesure.

Pour les affichages **monochromes** (unicolores), les "couleurs" sont toujours spécifiées comme étant simplement **1** (**afficher**) ou **0** (**effacer**). La sémantique **set/clear** est spécifique au type d'affichage : avec un affichage lumineux **OLED**, un pixel "set" est allumé, alors qu'avec un écran **LCD** réfléchissant, pour "set" le pixel est généralement sombre. Il peut y avoir des exceptions, mais généralement vous pouvez compter sur 0 (effacer) représentant l'état d'arrière-plan par défaut pour un affichage récemment initialisé.

== 3.3.3 Activités de programmation ==
<tabs>
  * [[#tab-micropy_5|MicroPython]]
  * [[#tab-circuitpy_5|CircuitPython]]
<pane id="tab-micropy_5">
  * **Ressources**
    * **Wiki** - [[python:micropython:materiel:ssd1306|MicroPython - Afficheurs à circuit SSD1306]]

  * **Etape 1** - Créer un nouveau programme
    - Cliquer sur l'icône **Nouveau** (Ctrl+N).
    - Copier-coller le code de l'exemple ci-dessous dans l'espace de travail de l'éditeur.

<code python afftemp.py>
# -------------------------------------------------------------------------------
# Exemple de code pour afficher la température délivrée par le capteur interne au
# microcontrôleur sur un afficheur graphique.
# Matériels : Raspberry Pi Pico, Shield Grove, afficheur à SSD1306
# Langage : MicroPython
# IDE : Thonny
# Source : afftemp.py
# Bibliothèque(s) : /lib/ssd1306.mpy
# -------------------------------------------------------------------------------
from machine import Pin, I2C
import ssd1306  # code de la bibliothèque à placer dans un dossier /lib sur le RP2

# BUS I2C0
i2c = I2C(0, sda=Pin(8), scl=Pin(9), freq=400_000)

# Afficheur oled (ssd1306) connecté au bus I2C0
oled_width = 128  # px
oled_height = 64  # px
oled = ssd1306.SSD1306_I2C(oled_width,oled_height, i2c)

# 1er affichage
oled.text("Mesure temp.", 5, 0)  # un caractère occupe 8px de haut
oled.show()

while True:
    pass
</code>

  * **Etape 2** - Enregistrer le programme
    * Enregistrer le programme dans votre compte sur le serveur en le nommant comme ci-dessus.

  * **Etape 3** - Tester le programme
    * Exécutez le programme en cliquant sur {{:python:micropython:startcoderp2.jpg?nolink|}}.

<callout type="question" title="MODIFICATION du PROGRAMME 3" color="red" icon="true">Le processeur du Raspberry Pi Pico intègre un capteur de température. Un exemple de code permettant de lire la température ambiante à l'aide du capteur de température interne au processeur est donné <html><a href="https://github.com/raspberrypi/pico-micropython-examples/blob/master/adc/temperature.py" target="_blank"><strong>ici</strong></a></html>. Ouvrir cet exemple et modifier le programme précédent pour qu'il affiche la température ambiante dans la console et sur l'afficheur graphique. \\ __Exemple d'affichage attendu__ : **T=22,9C** \\ __Remarque__ : Il faut effacer l'écran graphique avec une méthode //fill(0)// avant d'écrire dessus.</callout>
</pane>

<pane id="tab-circuitpy_5">
  * **Ressources**
    * Adafruit : <html><a href="https://learn.adafruit.com/adafruit-oled-featherwing/python-circuitpython-wiring" target="_blank">CircuitPython Wiring</a> | <a href="https://github.com/adafruit/Adafruit_CircuitPython_DisplayIO_SSD1306" target="_blank">Adafruit_CircuitPython_DisplayIO_SSD1306</a></html>

  * **Etape 1** - Créer un nouveau programme
    - Cliquer sur l'icône **Nouveau** (Ctrl+N)
    - Copier-coller le code de l'exemple ci-dessous dans l'espace de travail de l'éditeur.

<code python afftemp.py>
# -------------------------------------------------------------------------------
# Exemple de code pour afficher la température délivrée par le capteur interne au
# microcontrôleur sur un afficheur graphique.
# Matériels : Raspberry Pi Pico, Shield Grove, afficheur à SSD1306
# Langage : CircuitPython
# IDE : Thonny
# Source : afftemp.py
# Bibliothèque(s) : /font5x8.bin, /lib/adafruit_ssd1306.mpy,
# /lib/adafruit_framebuf.mpy
# -------------------------------------------------------------------------------
import board
import busio  # code de la bibliothèque à placer dans un dossier /lib sur le RP2
import adafruit_ssd1306
import time

# BUS I2C0
i2c = busio.I2C(board.GP9, board.GP8)

# Afficheur oled (ssd1306) connecté au bus I2C0
oled_width = 128  # px
oled_height = 64  # px
oled = adafruit_ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

# 1er Affichage
oled.text("Mesure temp.", 5, 0, 1)  # un caractère occupe 8px de haut
oled.show()

while True:
    pass
</code>

  * **Etape 2** - Enregistrer le programme
    * Enregistrer le programme avec le nom de l'exemple ci-dessus dans votre compte sur le serveur.

  * **Etape 3** - Tester le programme
    * Exécutez le script en cliquant sur {{:python:micropython:startcoderp2.jpg?nolink|}}.

<callout type="question" title="MODIFICATION du PROGRAMME 3" color="red" icon="true">Le processeur du Raspberry Pi Pico intègre un capteur de température. CircuitPython rend très simple la lecture de la température grâce au module //**microcontroller**//. Pour cela, il suffit d'écrire //microcontroller.cpu.temperature//. Modifier le programme précédent pour qu'il affiche la température ambiante dans la console et sur l'afficheur graphique. \\ __Exemple d'affichage attendu__ : **T=22,9C**.  \\ __Remarque__ : Il faut effacer l'écran graphique avec une méthode //fill(0)// avant d'écrire dessus.</callout>
</pane>
</tabs>


=== 3.4 Programme 4 - Capteur atmosphérique ===
{{ :python:micropython:ada2652.jpg?nolink|}}
<callout type="primary" title="Objectif" icon="true"> Afficher la température, l'humidité et la pression délivrées par un capteur à circuit **BME280** sur un afficheur graphique.</callout>

== 3.4.1 Matériels ==
    * **Afficheur graphique** : Wiki - [[materiels:afficheurs:ard0_96|0,96" 128x64 OLED 2864 Display module - SSD1306 (I2C)]]
    * **Capteur atmosphérique** : Wiki - [[materiels:capteurs:environnement:environnement|Capteurs - Environnement]]

== 3.4.2 Généralités ==
Le capteur utilisé est basé sur un circuit BME280 et mesure la température, l'humidité et la pression atmosphérique. Il communique avec un microcontrôleur via un bus I2C ou SPI.
  * **Caractéristiques**
    * Alimentation: 3,3 à 5 Vcc
    * Plages de mesure:
      * température: -40°C à 85°C
      * humidité: 0 à 100% HR
      * pression: 300 à 1100 hPa
    * Précision:
      * température: ±1°C (±0,5°C pour le BME680)
      * humidité: ±3%
      * pression: ±1 hPa (0,12hPa pour le BME680)
    * Interfaces: 
      * I2C: sur connecteur Qwiic de Sparkfun ou Stemma QT d'Adafruit. **Adresse I2C: 0x77** (0x76 via cavalier à connecter entre SDO et GND)
      * SPI: sur pastilles femelles au pas de 2,54 mm (connecteurs mâles à souder inclus)
      
== 3.4.3 Activités de programmation ==
<tabs>
  * [[#tab-micropy_6|MicroPython]]
  * [[#tab-circuitpy_6|CircuitPython]]
<pane id="tab-micropy_6">
  * **Ressources** sur Micropython.org.
    * <html><a href="https://docs.micropython.org/en/latest/rp2/quickref.html#hardware-i2c-bus" target="_blank">Hardware I2C bus</a></html>

  * **Etape 1** - Créer un nouveau programme
      - Cliquer sur l'icône **Nouveau** (Ctrl+N)
      - Copier-coller le code de l'exemple ci-dessous dans l'espace de travail de l'éditeur.

<code python affbme280.py>
# -------------------------------------------------------------------------------
# Exemple de code pour afficher la température, l'humidité et la pression 
# mesurées par un capteur BME280 sur un afficheur graphique .
# Matériels : Raspberry Pi Pico, Shield Grove, capteur BM280, afficheur à SSD1306
# Langage : MicroPython
# IDE : Thonny
# Source : affbme280.py,
# Bibliothèque(s) :  /lib/ssd1306.mpy, /lib/bme280.py
# -------------------------------------------------------------------------------
from machine import Pin, I2C
from time import sleep
import bme280  # code de la bibliothèque à placer dans un dossier /lib sur le RP2

# BUS I2C1
i2c = I2C(1, scl=Pin(7), sda=Pin(6), freq=400_000)

# Capteur BME280 connecté à I2C1 du shield Grove
bme = bme280.BME280(i2c=i2c)

while True:
    temp = bme.temperature
    hum = bme.humidity
    pres = bme.pressure
    print('Température: ', temp)
    print('Humidité: ', hum)
    print('Pression: ', pres)
    print('')
    sleep(2)
</code>

  * **Etape 2** - Enregistrer le programme
    * Enregistrer le programme dans votre compte sur le serveur en le nommant comme ci-dessus.

  * **Etape 3** - Tester le programme
    * Exécutez le programme en cliquant sur {{:python:micropython:startcoderp2.jpg?nolink|}}.

<callout type="question" title="MODIFICATION du PROGRAMME 4" color="red" icon="true">Modifiez le programme précédent pour qu'il affiche les 3 grandeurs physiques sur l'afficheur graphique. \\ __Exemple d'affichage attendu__ : \\ **BME280** \\ - **T = 23.94C** \\ - **H = 59.59%** \\ - **P = 992.54hPa**</callout>
</pane>

<pane id="tab-circuitpy_6">
  * **Ressources** sur doc.circuitpython.org.
    * <html><a href="https://docs.circuitpython.org/en/latest/shared-bindings/busio/index.html#busio.I2C" target="_blank">class busio.i2c</a></html>

  * **Etape 1** - Créer un nouveau programme
      - Cliquer sur l'icône **Nouveau** (Ctrl+N)
      - Copier-coller le code de l'exemple ci-dessous dans l'espace de travail de l'éditeur.

<code python affbme280.py>
# -------------------------------------------------------------------------------
# Exemple de code pour afficher la température, l'humidité, la pression et   
# l'altitude mesurées par un capteur BME280.
# Matériels : Raspberry Pi Pico, Shield Grove, capteur BM280, afficheur à ssd1306
# Langage : CircuitPython
# IDE : Thonny
# Fichiers : affbme280.py, /font5x8.bin, /lib/adafruit_ssd1306.mpy,
# /lib/adafruit_framebuf.mpy, /lib/adafruit_bme280.py
# -------------------------------------------------------------------------------
import board
import busio
from adafruit_bme280 import basic as adafruit_bme280
import time

# BUS I2C1
i2c = busio.I2C(board.GP7, board.GP6)  # SCL, SDA

# Capteur BME280 connecté à I2C1 du shield Grove
bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c)

# A modifier pour que cette valeur corresponde à la pression
# (hpa) au niveau de la mer (océan atlantique)
bme280.sea_level_pressure = 1016

while True:
    temp = bme280.temperature
    hum = bme280.humidity
    pres = bme280.pressure
    alt = bme280.altitude
    print('Température=', temp)
    print('Humidité: ', hum)
    print('Pression: ', pres)
    print('Altitude', alt)
    print('')
    time.sleep(2)
</code>

  * **Etape 2** - Enregistrer le programme
    * Enregistrer le programme dans votre compte sur le serveur en le nommant comme ci-dessus.

  * **Etape 3** - Tester le programme
    * Exécutez le programme en cliquant sur {{:python:micropython:startcoderp2.jpg?nolink|}}.

<callout type="question" title="MODIFICATION du PROGRAMME 4" color="red" icon="true">Modifiez le programme précédent pour qu'il affiche les 3 grandeurs physiques sur l'afficheur graphique. \\ __Exemple d'affichage attendu__ : \\ **BME280** \\ - **T = 23.22C** \\ - **H = 50.26%** \\ - **P = 999.70hPa** \\ - **Alt = 149.51m**</callout>
</pane>
</tabs>
=== 3.5 Programme 5 - Capteur de luminosité ===
{{ :python:micropython:ar-capteur-de-lumiere-tsl2591-ada1980-22971.jpg?nolink&200|}}
<callout type="primary" title="Objectif" icon="true">Afficher la luminosité ambiante sur un afficheur graphique.</callout>

== 3.5.1 Matériels ==
  * **Afficheur graphique** : Wiki - [[materiels:afficheurs:ard0_96|0,96" 128x64 OLED 2864 Display module - SSD1306 (I2C)]]
  * **Capteur de luminosité** : Wiki - [[materiels:capteurs:eclairement:luminosite|Capteurs - Eclairement]]

== 3.5.2 Généralités ==
Le capteur utilisé est basé sur un circuit TSL2591 permettant de mesurer l'éclairement lumineux. Ce capteur communique avec un microcontrôleur via le bus I2C.

  * **Caractéristiques**
    * Alimentation: 3,3 à 5 Vcc
    * Interface I2C:
      * Adresse I2C: 0x29 et 0x28 (l'adresse ne peut pas être changée)
    * Plage de mesure: 188 µLux à 88000 Lux

== 3.5.3 Activités de programmation ==
<tabs>
  * [[#tab-micropy_7|MicroPython]]
  * [[#tab-circuitpy_7|CircuitPython]]

<pane id="tab-micropy_7">
  * **Ressources** sur Micropython.org.
    * <html><a href="https://docs.micropython.org/en/latest/rp2/quickref.html#hardware-i2c-bus" target="_blank">Hardware I2C bus</a></html>

  * **Etape 1** - Créer un nouveau programme
      - Cliquer sur l'icône **Nouveau** (Ctrl+N)
      - Copier-coller le code de l'exemple ci-dessous dans l'espace de travail de l'éditeur.

<code python tst_tsl2591.py>
# -------------------------------------------------------------------------------
# Affichage de la luminosité mesurée par un capteur TSL2591 dans la console
# Date : 7/7/2023
# Matériels : Raspberry Pi Pico, TSL2591, Shield Grove, adaptateur Qwiic,
# câble Qwiic 5cm
# Langage : MicroPython
# IDE : Thonny
# Fichiers : demoTSL2591.py, /lib/tsl2591.py
# Source : https://github.com/mchobby/esp8266-upy/tree/master/tsl2591
# -------------------------------------------------------------------------------

from tsl2591 import * # Pilote du module
from machine import Pin, I2C # Pilote du bus I2C
from time import sleep # pour temporiser

# Bus I2C1
i2c = I2C(1, scl=Pin(7), sda=Pin(6), freq=400_000)

sleep(1) # Pause d'une seconde pour laisser à l'I2C le temps de s'initialiser

tsl = TSL2591( i2c ) # Instanciation du capteur

while True:
	print( "Eclairement : %.1f lx" % tsl.lux ) # Lecture d'une valeur
	ir = tsl.infrared                          # Valeur entière proportionelle à l'éclairement infrarouge
	vi = tsl.visible                           # Valeur entière proportionelle à l'éclairement visible
	total = ir + vi                            # Somme des deux ...
	
	if total !=0:
		inv_total = 100 / total
		print("Infrarouge : %.1f %%" %(ir*inv_total))
		print("Lumière visible : %1.f %%" %(vi*inv_total))
	print("")
	sleep(5) # Temporisation de 5 secondes
</code>

  * **Etape 2** - Enregistrer le programme
    * Enregistrer le programme dans votre compte sur le serveur en le nommant comme ci-dessus.

  * **Etape 3** - Tester le programme
    * Exécutez le programme en cliquant sur {{:python:micropython:startcoderp2.jpg?nolink|}}.

<callout type="question" title="MODIFICATION du PROGRAMME 5" color="red" icon="true">Modifiez le programme précédent pour qu'il affiche les 3 grandeurs physiques sur l'afficheur graphique. \\ __Exemple d'affichage attendu__ : \\ **TSL2561** \\ - **Ecl. = 207.4lx** \\ - **Ir = 0%** \\ - **Lum. vis. = 100%**</callout>
</pane>

<pane id="tab-circuitpy_7">
  * **Ressources** sur doc.circuitpython.org.
    * <html><a href="https://docs.circuitpython.org/en/latest/shared-bindings/busio/index.html#busio.I2C" target="_blank">class busio.i2c</a></html>

  * **Etape 1** - Créer un nouveau programme
      - Cliquer sur l'icône **Nouveau** (Ctrl+N)
      - Copier-coller le code de l'exemple ci-dessous dans l'espace de travail de l'éditeur.

<code python affbme280.py>
</code>


  * **Etape 2** - Enregistrer le programme
    * Enregistrer le programme dans votre compte sur le serveur en le nommant comme ci-dessus.

  * **Etape 3** - Tester le programme
    * Exécutez le programme en cliquant sur {{:python:micropython:startcoderp2.jpg?nolink|}}.

<callout type="question" title="MODIFICATION du PROGRAMME 5" color="red" icon="true">
</callout>
</pane>
</tabs>
=== 3.6 Serveur WEB ===
  * <color #ed1c24>Ressource provisoire</color> : <html><a href="https://randomnerdtutorials.com/esp32-esp8266-micropython-web-server/" target="_blank">ESP32/ESP8266 MicroPython Web Server</a></html>

<color #ed1c24>A faire</color>

=== Pour aller plus loin ===
 - **Tutoriels** sur <html><a href="https://randomnerdtutorials.com/projects-esp32-esp8266-micropython/" target="_blank">RANDOM NERD TUTORIALS</a></html>((Random Nerd Tutorials helps makers, hobbyists and engineers build electronics projects. We make projects with: ESP32, ESP8266, Arduino, Raspberry Pi, ...))