Aller au contenu

II) Débuter avec l'ESP32 en Micropython

1) Présentation de l'ESP32

L'ESP32 est un microcontrôleur : c'est une sorte d'ordinateur avec de la mémoire et un processeur. Son objectif est de contrôler les entrées et les sorties que l'ont brancher sur ses pattes (voir l'image ci-dessus).

Quelques caractéristiques :

  • une tension de fonctionnement de 3,3V ;
  • une mémoire SRAM de 512 ko ;
  • une mémoire ROM de 2 Mo ;
  • Bluetooth ;
  • Wifi.

2) Présentation de Micropython

Micropython est une implémentation du langage Python adaptée aux microcontrôleurs.

Ainsi, un microcontrôleur comme l'ESP32 sera capable d'exécuter des programmes Python.

Pour cela, cette implémentation est allégée et permet de gérer les entrées et les sorties.

Cette exemple sert à illustrer le contrôle d'une patte en sortie (Pin.OUT).

On parle ici de sortie "digital" car la valeur est soit 1 (alimentée en 3,3V), soit 0 (reliée à la masse).

Ceci peut s'appliquer à différentes choses : - allumer ou éteindre une led - ouvrir ou fermer un interrupteur (un relais) - activer ou non un capteur - ...

a) Avec une boucle infinie

Ce programme a le mérite de mettre en évidence le fonctionnement séquentiel.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import machine
import time

led = machine.Pin(2, machine.Pin.OUT) #D2 : led de la plaque

while(True):
    led.value(1)
    time.sleep_ms(1000)
    led.value(0)
    time.sleep_ms(1000)
  • Ligne 4 : on crée l'objet led, de type Pin comme une sortie. La patte D2 correspond à la led embarquée.
  • Ligne 6 : on crée la boucle infinie.
  • Ligne 7 : on allume la led.
  • Ligne 8 : on attend une seconde.
  • Ligne 9 : on éteint la led.
  • Ligne 10 : on attend une seconde

Attention : la commande sleep_ms() bloque toutes les actions, ce qui peut être gênant ...

b) Avec un timer

Ce programme donne plus d'options car l'utilisation d'un timer permet d'intercaler d'autres actions.

À noter qu'on n'utilise pas la commande sleep_ms().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import machine

###############################
def basculer_led(timer):
    """  Fonction callback qui  bascule l'état de la led."""
    etat = led.value()
    if etat==0:
        led.value(1)
    else :
        led.value(0)

##############################

led = machine.Pin(2, machine.Pin.OUT) #D2 : led de la plaque
timer0 = machine.Timer(0)

timer0.init(period = 1000,callback=basculer_led)
  • Ligne 4 : on crée la fonction callback appelée par le timer toutes les secondes.
  • Ligne 6 : cette fois-ci, on utilise la fonction value() pour lire l'état de la led qui pourtant est une sortie.
  • Ligne 15 : on crée un timer d'identifiant 0 (on peut les nommer de 0 à 3).
  • Ligne 17 : on initialise le timer.

4) Faire varier la luminosité de la led embarquée

Nous allons illustrer le fonctionnement en PWM (Pulse Width Modulation) d'une patte (Pin).

L'idée pour obtenir une valeur intermédiaire entre 0 et 3,3V est de passer très souvent de l'état haut à l'état bas. Nous ne détaillerons pas ici ce principe.

La fonction duty() permet d'attribuer une valeur entre 0 et 1023.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import machine
import time

#######################################
def varier_led(led,t) :
    """Fonction faisant s'allumant puis s'éteindre progressivement la led."""
    print(time.time())
    for k in range(50):
        led.duty(k*20)
        time.sleep_ms(t)
    for k in range(1,51):
        led.duty(1000-k*20)
        time.sleep_ms(t)
#######################################

led_emb = machine.PWM(machine.Pin(2), duty=0)
timer0 = machine.Timer(0)
timer1 = machine.Timer(1)

timer0.init(period=1000,callback=lambda t:varier_led(led_emb,50))
timer1.init(period=5000,mode=machine.Timer.ONE_SHOT,callback=lambda t:timer0.deinit())
  • Ligne 4 : on crée la fonction callback.
  • Ligne 9 et 12 : on fait varier la luminosité. Le paramètre de duty() va varier entre 0 et 1000.
  • Ligne 16 : on crée l'objet led_emb de type PWM et on l'éteint.
  • Ligne 20 : on initialise le timer0 qui va faire varier la led toutes les 10 secondes.
  • Ligne 21 : on initialise le timer1 qui va arrêter le timer0 au bout de 50 secondes. Ce timer n'agit qu'une fois (ONE_SHOT).

5) Lecture des valeurs d'un joystick

Cet exemple va nous permettre d'illustrer les deux types de lecture :

  • avec la fonction value() qui renvoie 0 ou 1 ;
  • avec les convertisseurs ADC (Analog Digital Conversor) : ils renvoient des valeurs entre 0 et 4095.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import machine
import time

analogPinX = machine.ADC(machine.Pin(13))
analogPinY = machine.ADC(machine.Pin(12))

analogPinX.atten(machine.ADC.ATTN_11DB)
analogPinY.atten(machine.ADC.ATTN_11DB)

sw = machine.Pin(14,machine.Pin.IN,machine.Pin.PULL_UP)

while True :
    val_X = analogPinX.read()
    val_Y = analogPinY.read()
    val_sw = sw.value()
    print(f"X : {val_X}  Y : {val_Y} sc : {val_sw}")
    time.sleep_ms(1000)
  • Ligne 4 : on crée l'objet ADC analogPinX.
  • Ligne 5 : on crée l'objet ADC analogPinY.
  • Ligne 7 et 8 : il faut cette atténuation pour l'ESP32.
  • Ligne 10 : on crée l'objet Pin sw pour le bouton du joystick.