b. Configuration d'une broche en sortie

• Ressource : pinMode() sur le site arduino.cc

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

c. Ecriture d'un état logique sur une broche

• Ressource : digitalWrite() sur le site arduino.cc

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

d. Synthèse: blink

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

b. Configuration d'une broche en sortie

• Ressources sur Micropython.org.
  • module machine | class Pin – control I/O pins

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

c. Ecriture d'un état logique sur une broche

• Ressources sur Micropython.org.
  • module machine | class Pin – control I/O pins

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

d. Synthèse: Blink.py

• Ressources sur Micropython.org.
  • module machine | module time | class Pin – control I/O pins
  • Quick reference for the Rp2, Pins and GPIO.

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(15,Pin.OUT) # (GPIO15)
 
while (True):
    led.on()
    time.sleep(0.5) # Attente 0,5s
    led.off()
    time.sleep(0.5) # Attente 0,5s

b. Configuration d'une broche en sortie

• Ressources sur MicroPython.org
  • module machine | class Pin – control I/O pins

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

c. Ecriture d'un état logique sur une broche

• Ressources sur Micropython.org.
  • module machine | class Pin – control I/O pins

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

d. Synthèse: Blink.py

• Ressources sur Micropython.org.
  • module machine | module time | class Pin – control I/O pins
  • Quick reference for the ESP32, Pins and GPIO.

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

• Ressource : analogWrite() sur le site arduino.cc

a. Présentation

b. Configuration d'une broche en sortie et génération d'un signal PWM

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

b. Configuration d'une broche en entrée

• Ressource : pinMode() sur le site arduino.cc

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

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

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

• Ressource : digitalRead() sur le site arduino.cc

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

d. Synthèse: ledbp

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

• Ressources sur Micropython.org.
  • module machine | module time | class Pin – control I/O pins
  • Quick reference for the RP2, Pins and GPIO

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

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

• Ressources sur Micropython.org.
  • module machine | module time | class Pin – control I/O pins
  • Quick reference for the ESP32, Pins and GPIO

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

*.py

# Configuration (en entrée) des broches connectées à deux boutons-poussoirs
button_min = Pin(25, Pin.IN)
button_hr = Pin(26, Pin.IN)
...

• Ressource :

a. Présentation
b. Configuration d'une broche en entrée d'interruption
c. Evènement et gestionnaire d'interruption
d. Synthèse: ?

• Ressource :

a. Présentation
b. Configuration d'une broche en entrée d'interruption
c. Evènement et gestionnaire d'interruption
d. Synthèse: ?

• Ressource : Quick reference for ESP32, GPIO Pins, External interrupts sur Micropython.org.

a. Présentation

• Ressource provisoire MicroPython: Interrupts with ESP32 and ESP8266

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

c. Evènement et gestionnaire d'interruption

d. Synthèse: HORLOGE NUMERIQUE

• Matériel : ESP32 Feather Huzzah, Digilent Pmod BTN: 4 User Pushbuttons [Schéma]

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

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

d. Synthèse: ?

• Ressource
  • ADC (analog to digital conversion) | class Pin – control I/O pins sur Micropython.org.

Exemple de code pour un Raspberry Pi Pico

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

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

c. Lecture d'une entrée analogique

d. Synthèse: ?

• Ressource
  • ADC (analog to digital conversion) sur Micropython.org.

Exemple de code pour un ESP32 Feather Huzzah

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