MicroPython : Capteur à ultrasons HC-SR04 ESP32/ESP8266

Dans ce guide, vous apprendrez à utiliser le capteur à ultrasons HC-SR04 avec l’ESP32 et l’ESP8266 pour obtenir la distance à un objet à l’aide du micrologiciel MicroPython. Ce didacticiel explique comment câbler le capteur aux cartes ESP32 et ESP8266 et fournit un script MicroPython simple pour obtenir la distance à un objet et l’afficher sur un écran OLED.

Conditions préalables

Pour suivre ce tutoriel, vous avez besoin du firmware MicroPython installé dans vos cartes ESP32 ou ESP8266. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre carte. Nous vous suggérons d’utiliser Thonny IDE ou uPyCraft IDE :

Ou, si vous connaissez VS Code, vous pouvez utiliser l’extension PyMakr :

En savoir plus sur MicroPython : eBook de programmation MicroPython avec ESP32 et ESP8266.

Vous aimerez peut-être également lire d’autres guides d’ultrasons HC-SR04 :

Présentation du capteur à ultrasons HC-SR04

Le capteur à ultrasons HC-SR04 utilise un sonar pour déterminer la distance à un objet. Ce capteur lit de 2 cm à 400 cm (0,8 pouce à 157 pouces) avec une précision de 0,3 cm (0,1 pouce), ce qui convient à la plupart des projets amateurs. De plus, ce module particulier est livré avec des modules émetteurs et récepteurs à ultrasons.

L’image suivante montre le capteur à ultrasons HC-SR04.

L’image suivante montre l’autre côté du capteur.

Où acheter le capteur à ultrasons HC-SR04 ?

Vous pouvez consulter le capteur à ultrasons HC-SR04 sur Maker Advisor pour trouver le meilleur prix :

Données techniques du capteur à ultrasons HC-SR04

Le tableau suivant présente les principales caractéristiques et spécifications du capteur à ultrasons HC-SR04. Pour plus d’informations, vous devez consulter la fiche technique du capteur.

Brochage du capteur à ultrasons HC-SR04

Voici le brochage du capteur à ultrasons HC-SR04.

Comment fonctionne le capteur à ultrasons HC-SR04 ?

Le capteur à ultrasons utilise un sonar pour déterminer la distance à un objet. Voici comment ça fonctionne:

1. L’émetteur d’ultrasons (trig pin) émet un son à haute fréquence (40 kHz).
2. Le son voyage dans l’air. S’il trouve un objet, il rebondit vers le module.
3. Le récepteur d’ultrasons (broche d’écho) reçoit le son réfléchi (écho).

En tenant compte de la vitesse du son dans l’air et du temps de trajet (temps écoulé depuis l’émission et la réception du signal) on peut calculer la distance à un objet. Voici la formule :

distance to an object = ((speed of sound in the air)*time)/2

• vitesse du son dans l’air à 20ºC (68ºF) = 343 m/s

Pièces requises

Pour terminer ce tutoriel, vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou aller directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Schéma – ESP32 avec capteur à ultrasons HC-SR04

Câblez le capteur à ultrasons HC-SR04 à l’ESP32 comme indiqué dans le schéma suivant. Nous connectons la broche Trig à GPIO 5 et la broche Echo pour GPIO 18, mais vous pouvez utiliser n’importe quelle autre broche appropriée. Passez à la section suivante si vous utilisez une carte ESP8266.

Lecture recommandée: Guide de référence du brochage ESP32

Schéma – ESP8266 avec capteur à ultrasons HC-SR04

Câblez le capteur à ultrasons HC-SR04 à l’ESP8266 comme indiqué dans le schéma suivant. Nous connectons la broche Trig à GPIO 12 et la broche Echo pour GPIO 14, mais vous pouvez utiliser n’importe quelle autre broche appropriée.

Lecture recommandée: Guide de référence du brochage ESP8266

Bibliothèque MicroPython HC-SR04

Il existe plusieurs façons d’obtenir la distance d’un objet à l’aide des cartes HC-SR04 et ESP32/ESP8266 à l’aide du micrologiciel MicroPython. Nous utiliserons ceci Bibliothèque MicroPython HC-SR04 cela facilite l’interface du capteur et l’obtention de mesures.

La bibliothèque que nous utiliserons ne fait pas partie de la bibliothèque MicroPython standard par défaut. Vous devez donc télécharger la bibliothèque suivante sur votre carte ESP32/ESP8266 (enregistrez-la sous le nom hcsr04.py).

import machine, time
from machine import Pin

__version__ = '0.2.0'
__author__ = 'Roberto Sánchez'
__license__ = "Apache License 2.0. https://www.apache.org/licenses/LICENSE-2.0"

class HCSR04:
    """
    Driver to use the untrasonic sensor HC-SR04.
    The sensor range is between 2cm and 4m.
    The timeouts received listening to echo pin are converted to OSError('Out of range')
    """
    # echo_timeout_us is based in chip range limit (400cm)
    def __init__(self, trigger_pin, echo_pin, echo_timeout_us=500*2*30):
        """
        trigger_pin: Output pin to send pulses
        echo_pin: Readonly pin to measure the distance. The pin should be protected with 1k resistor
        echo_timeout_us: Timeout in microseconds to listen to echo pin. 
        By default is based in sensor limit range (4m)
        """
        self.echo_timeout_us = echo_timeout_us
        # Init trigger pin (out)
        self.trigger = Pin(trigger_pin, mode=Pin.OUT, pull=None)
        self.trigger.value(0)

        # Init echo pin (in)
        self.echo = Pin(echo_pin, mode=Pin.IN, pull=None)

    def _send_pulse_and_wait(self):
        """
        Send the pulse to trigger and listen on echo pin.
        We use the method `machine.time_pulse_us()` to get the microseconds until the echo is received.
        """
        self.trigger.value(0) # Stabilize the sensor
        time.sleep_us(5)
        self.trigger.value(1)
        # Send a 10us pulse.
        time.sleep_us(10)
        self.trigger.value(0)
        try:
            pulse_time = machine.time_pulse_us(self.echo, 1, self.echo_timeout_us)
            return pulse_time
        except OSError as ex:
            if ex.args[0] == 110: # 110 = ETIMEDOUT
                raise OSError('Out of range')
            raise ex

    def distance_mm(self):
        """
        Get the distance in milimeters without floating point operations.
        """
        pulse_time = self._send_pulse_and_wait()

        # To calculate the distance we get the pulse_time and divide it by 2 
        # (the pulse walk the distance twice) and by 29.1 becasue
        # the sound speed on air (343.2 m/s), that It's equivalent to
        # 0.34320 mm/us that is 1mm each 2.91us
        # pulse_time // 2 // 2.91 -> pulse_time // 5.82 -> pulse_time * 100 // 582 
        mm = pulse_time * 100 // 582
        return mm

    def distance_cm(self):
        """
        Get the distance in centimeters with floating point operations.
        It returns a float
        """
        pulse_time = self._send_pulse_and_wait()

        # To calculate the distance we get the pulse_time and divide it by 2 
        # (the pulse walk the distance twice) and by 29.1 becasue
        # the sound speed on air (343.2 m/s), that It's equivalent to
        # 0.034320 cm/us that is 1cm each 29.1us
        cms = (pulse_time / 2) / 29.1
        return cms

Afficher le code brut

Suivez les instructions suivantes pour l’IDE que vous utilisez :

• A. Téléchargez la bibliothèque HC-SR04 avec IDE uPyCraft
• B. Téléchargez la bibliothèque HC-SR04 avec Thonny IDE

Avant de passer à la section suivante, assurez-vous que le micrologiciel MicroPython a été flashé sur vos cartes ESP32 ou ESP8266. Vous pouvez suivre l’un des tutoriels suivants :

A. Télécharger la bibliothèque HC-SR04 avec uPyCraft IDE

Cette section montre comment télécharger une bibliothèque à l’aide de l’IDE uPyCraft. Si vous utilisez Thonny IDE, lisez la section suivante.

Tout d’abord, assurez-vous d’avoir une connexion entre l’IDE et votre carte. Aller à Outils > En série et sélectionnez le port COM. Aller à Outils > Conseil et sélectionnez le tableau. Ensuite, cliquez sur le Relier bouton.

1. Créez un nouveau fichier en appuyant sur le Nouveau fichier bouton (1).

2. Copiez le code de la bibliothèque HC-SR04 dans ce fichier. Le code de la bibliothèque HC-SR04 peut être trouvé ici.

3. Après avoir copié le code, enregistrez le fichier en appuyant sur la touche Sauvegarder bouton (2).

4. Appelez ce nouveau fichier hcsr04.py et appuyez sur d’accord.

5. Cliquez sur le Télécharger et exécuter (3) bouton.

Après cela, le fichier doit se trouver dans le dossier de l’appareil avec le nom hcsr04.py, comme le montre la figure suivante.

Maintenant, vous pouvez utiliser les fonctionnalités de la bibliothèque dans votre code en important la bibliothèque.

B. Télécharger la bibliothèque HC-SR04 avec Thonny IDE

Si vous utilisez Thonny IDE, suivez les étapes suivantes :

1. Copiez le code de la bibliothèque dans un nouveau fichier. Le code de la bibliothèque HC-SR04 peut être trouvé ici.

2. Aller à Déposer > Enregistrer sous…

3. Sélectionnez enregistrer dans « Périphérique MicroPython » :

4. Nommez votre fichier comme hcsr04.py et appuyez sur le bouton OK :

Et c’est tout. La bibliothèque a été téléchargée sur votre tableau. Pour vous assurer qu’il a été téléchargé avec succès, accédez à Déposer > Enregistrer sous… et sélectionnez le périphérique MicroPython. Votre fichier doit y figurer :

Après avoir téléchargé la bibliothèque sur votre tableau, vous pouvez utiliser les fonctionnalités de la bibliothèque dans votre code en important la bibliothèque.

Code – Capteur à ultrasons HC-SR04

Après avoir téléchargé la bibliothèque sur l’ESP32 ou l’ESP8266, copiez le code suivant dans le main.py ou boot.py déposer. Il imprime simplement la distance à l’objet le plus proche toutes les secondes (exemple adapté du page de la bibliothèque).

# Complete project details at https://Raspberryme.com/micropython-hc-sr04-ultrasonic-esp32-esp8266/
from hcsr04 import HCSR04
from time import sleep

# ESP32
sensor = HCSR04(trigger_pin=5, echo_pin=18, echo_timeout_us=10000)

# ESP8266
#sensor = HCSR04(trigger_pin=12, echo_pin=14, echo_timeout_us=10000)

while True:
    distance = sensor.distance_cm()
    print('Distance:', distance, 'cm')
    sleep(1)

Afficher le code brut

Comment fonctionne le code

Tout d’abord, vous devez importer les bibliothèques nécessaires : importez le HCSR04 classe de la hcsr04 bibliothèque. De plus, vous devez également importer le temps bibliothèque pour ajouter des délais à notre code.

from hcsr04 import HCSR04
from time import sleep

Ensuite, créez un HCSR04 objet appelé capteur qui fait référence au capteur HCSR04. Passez comme arguments la broche de déclenchement, la broche d’écho et le délai d’attente (temps de trajet maximal de l’onde sonore – lorsque le capteur est probablement hors de portée).

sensor = HCSR04(trigger_pin=5, echo_pin=18, echo_timeout_us=10000)

Si vous utilisez l’ESP8266, commentez la ligne précédente et décommentez ce qui suit pour utiliser différentes broches :

sensor = HCSR04(trigger_pin=12, echo_pin=14, echo_timeout_us=10000)

Pour obtenir la distance en cm, il suffit d’appeler le distance_cm méthode sur le capteur objet. Enregistrez le résultat dans le distance variable.

distance = sensor.distance_cm()

La bibliothèque fournit également une méthode pour obtenir la distance en millimètres sans virgule flottante. Il vous suffit d’appeler :

distance = sensor.distance_mm()

Imprimez la distance sur la coque Micropython.

print('Distance:', distance, 'cm')

Au final, on ajoute un délai d’une seconde (la distance est mise à jour toutes les secondes) :

sleep(1)

Manifestation

Après avoir téléchargé le code sur votre tableau, appuyez sur le bouton RST pour exécuter le code. La distance à l’objet le plus proche doit être imprimée sur la coque.

Distance d’affichage (HCSR04) sur l’écran OLED

Maintenant que vous savez comment obtenir la distance jusqu’à l’objet le plus proche à l’aide d’un capteur à ultrasons HC-SR04, nous allons afficher les lectures du capteur sur un écran OLED.

Pièces requises

Voici une liste des pièces requises pour compléter cet exemple :

Vous pouvez utiliser les liens précédents ou aller directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Diagramme schématique

Ajoutez un écran I2C OLED au circuit précédent. Suivez le schéma de principe de la carte que vous utilisez.

ESP32

ESP8266

Des dossiers

Pour cet exemple, vous avez besoin de trois fichiers :

• hcsr04.py: c’est le fichier qui contient toutes les méthodes pour utiliser le capteur HC-SR04. C’est le fichier que vous avez téléchargé précédemment.
• ssd1306.py: il s’agit de la bibliothèque de l’écran OLED SSD1306 I2C. Vous devez le télécharger sur votre tableau pour pouvoir communiquer et écrire sur l’écran.
• main.py: c’est le script principal pour obtenir la distance et l’afficher sur l’écran OLED.

ssd1306.py

Créez un nouveau fichier appelé ss1306.py et copiez le code suivant. Ensuite, téléchargez-le sur votre tableau.

#MicroPython SSD1306 OLED driver, I2C and SPI interfaces created by Adafruit

import time
import framebuf

# register definitions
SET_CONTRAST        = const(0x81)
SET_ENTIRE_ON       = const(0xa4)
SET_NORM_INV        = const(0xa6)
SET_DISP            = const(0xae)
SET_MEM_ADDR        = const(0x20)
SET_COL_ADDR        = const(0x21)
SET_PAGE_ADDR       = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP       = const(0xa0)
SET_MUX_RATIO       = const(0xa8)
SET_COM_OUT_DIR     = const(0xc0)
SET_DISP_OFFSET     = const(0xd3)
SET_COM_PIN_CFG     = const(0xda)
SET_DISP_CLK_DIV    = const(0xd5)
SET_PRECHARGE       = const(0xd9)
SET_VCOM_DESEL      = const(0xdb)
SET_CHARGE_PUMP     = const(0x8d)


class SSD1306:
    def __init__(self, width, height, external_vcc):
        self.width = width
        self.height = height
        self.external_vcc = external_vcc
        self.pages = self.height // 8
        # Note the subclass must initialize self.framebuf to a framebuffer.
        # This is necessary because the underlying data buffer is different
        # between I2C and SPI implementations (I2C needs an extra byte).
        self.poweron()
        self.init_display()

    def init_display(self):
        for cmd in (
            SET_DISP | 0x00, # off
            # address setting
            SET_MEM_ADDR, 0x00, # horizontal
            # resolution and layout
            SET_DISP_START_LINE | 0x00,
            SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0
            SET_MUX_RATIO, self.height - 1,
            SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0
            SET_DISP_OFFSET, 0x00,
            SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,
            # timing and driving scheme
            SET_DISP_CLK_DIV, 0x80,
            SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
            SET_VCOM_DESEL, 0x30, # 0.83*Vcc
            # display
            SET_CONTRAST, 0xff, # maximum
            SET_ENTIRE_ON, # output follows RAM contents
            SET_NORM_INV, # not inverted
            # charge pump
            SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,
            SET_DISP | 0x01): # on
            self.write_cmd(cmd)
        self.fill(0)
        self.show()

    def poweroff(self):
        self.write_cmd(SET_DISP | 0x00)

    def contrast(self, contrast):
        self.write_cmd(SET_CONTRAST)
        self.write_cmd(contrast)

    def invert(self, invert):
        self.write_cmd(SET_NORM_INV | (invert & 1))

    def show(self):
        x0 = 0
        x1 = self.width - 1
        if self.width == 64:
            # displays with width of 64 pixels are shifted by 32
            x0 += 32
            x1 += 32
        self.write_cmd(SET_COL_ADDR)
        self.write_cmd(x0)
        self.write_cmd(x1)
        self.write_cmd(SET_PAGE_ADDR)
        self.write_cmd(0)
        self.write_cmd(self.pages - 1)
        self.write_framebuf()

    def fill(self, col):
        self.framebuf.fill(col)

    def pixel(self, x, y, col):
        self.framebuf.pixel(x, y, col)

    def scroll(self, dx, dy):
        self.framebuf.scroll(dx, dy)

    def text(self, string, x, y, col=1):
        self.framebuf.text(string, x, y, col)


class SSD1306_I2C(SSD1306):
    def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):
        self.i2c = i2c
        self.addr = addr
        self.temp = bytearray(2)
        # Add an extra byte to the data buffer to hold an I2C data/command byte
        # to use hardware-compatible I2C transactions.  A memoryview of the
        # buffer is used to mask this byte from the framebuffer operations
        # (without a major memory hit as memoryview doesn't copy to a separate
        # buffer).
        self.buffer = bytearray(((height // 8) * width) + 1)
        self.buffer[0] = 0x40  # Set first byte of data buffer to Co=0, D/C=1
        self.framebuf = framebuf.FrameBuffer1(memoryview(self.buffer)[1:], width, height)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.temp[0] = 0x80 # Co=1, D/C#=0
        self.temp[1] = cmd
        self.i2c.writeto(self.addr, self.temp)

    def write_framebuf(self):
        # Blast out the frame buffer using a single I2C transaction to support
        # hardware I2C interfaces.
        self.i2c.writeto(self.addr, self.buffer)

    def poweron(self):
        pass


class SSD1306_SPI(SSD1306):
    def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
        self.rate = 10 * 1024 * 1024
        dc.init(dc.OUT, value=0)
        res.init(res.OUT, value=0)
        cs.init(cs.OUT, value=1)
        self.spi = spi
        self.dc = dc
        self.res = res
        self.cs = cs
        self.buffer = bytearray((height // 8) * width)
        self.framebuf = framebuf.FrameBuffer1(self.buffer, width, height)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs.high()
        self.dc.low()
        self.cs.low()
        self.spi.write(bytearray([cmd]))
        self.cs.high()

    def write_framebuf(self):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs.high()
        self.dc.high()
        self.cs.low()
        self.spi.write(self.buffer)
        self.cs.high()

    def poweron(self):
        self.res.high()
        time.sleep_ms(1)
        self.res.low()
        time.sleep_ms(10)
        self.res.high()

Afficher le code brut

hcsr04.py

Téléchargez le hcsr04.py à votre conseil d’administration.

import machine, time
from machine import Pin

__version__ = '0.2.0'
__author__ = 'Roberto Sánchez'
__license__ = "Apache License 2.0. https://www.apache.org/licenses/LICENSE-2.0"

class HCSR04:
    """
    Driver to use the untrasonic sensor HC-SR04.
    The sensor range is between 2cm and 4m.
    The timeouts received listening to echo pin are converted to OSError('Out of range')
    """
    # echo_timeout_us is based in chip range limit (400cm)
    def __init__(self, trigger_pin, echo_pin, echo_timeout_us=500*2*30):
        """
        trigger_pin: Output pin to send pulses
        echo_pin: Readonly pin to measure the distance. The pin should be protected with 1k resistor
        echo_timeout_us: Timeout in microseconds to listen to echo pin. 
        By default is based in sensor limit range (4m)
        """
        self.echo_timeout_us = echo_timeout_us
        # Init trigger pin (out)
        self.trigger = Pin(trigger_pin, mode=Pin.OUT, pull=None)
        self.trigger.value(0)

        # Init echo pin (in)
        self.echo = Pin(echo_pin, mode=Pin.IN, pull=None)

    def _send_pulse_and_wait(self):
        """
        Send the pulse to trigger and listen on echo pin.
        We use the method `machine.time_pulse_us()` to get the microseconds until the echo is received.
        """
        self.trigger.value(0) # Stabilize the sensor
        time.sleep_us(5)
        self.trigger.value(1)
        # Send a 10us pulse.
        time.sleep_us(10)
        self.trigger.value(0)
        try:
            pulse_time = machine.time_pulse_us(self.echo, 1, self.echo_timeout_us)
            return pulse_time
        except OSError as ex:
            if ex.args[0] == 110: # 110 = ETIMEDOUT
                raise OSError('Out of range')
            raise ex

    def distance_mm(self):
        """
        Get the distance in milimeters without floating point operations.
        """
        pulse_time = self._send_pulse_and_wait()

        # To calculate the distance we get the pulse_time and divide it by 2 
        # (the pulse walk the distance twice) and by 29.1 becasue
        # the sound speed on air (343.2 m/s), that It's equivalent to
        # 0.34320 mm/us that is 1mm each 2.91us
        # pulse_time // 2 // 2.91 -> pulse_time // 5.82 -> pulse_time * 100 // 582 
        mm = pulse_time * 100 // 582
        return mm

    def distance_cm(self):
        """
        Get the distance in centimeters with floating point operations.
        It returns a float
        """
        pulse_time = self._send_pulse_and_wait()

        # To calculate the distance we get the pulse_time and divide it by 2 
        # (the pulse walk the distance twice) and by 29.1 becasue
        # the sound speed on air (343.2 m/s), that It's equivalent to
        # 0.034320 cm/us that is 1cm each 29.1us
        cms = (pulse_time / 2) / 29.1
        return cms

Afficher le code brut

main.py

Dans le main.py fichier est l’endroit où nous obtiendrons la distance et l’afficherons sur l’écran OLED.

# Complete project details at https://Raspberryme.com/micropython-hc-sr04-ultrasonic-esp32-esp8266/
from machine import Pin, I2C
import ssd1306
from hcsr04 import HCSR04
from time import sleep

# ESP32 Pin assignment 
i2c = I2C(scl=Pin(22), sda=Pin(21))
sensor = HCSR04(trigger_pin=5, echo_pin=18, echo_timeout_us=10000)

# ESP8266 Pin assignment
#i2c = I2C(scl=Pin(5), sda=Pin(4))
#sensor = HCSR04(trigger_pin=12, echo_pin=14, echo_timeout_us=10000)

oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

while True:
  oled.fill(0)
  #oled.show()
  distance = sensor.distance_mm()
  print('Distance:', distance, 'mm')
  oled.text("Distance (mm)", 0, 15)
  oled.text(str(distance), 0, 35)
  oled.show()
  sleep(1)

Afficher le code brut

Le code est simple à comprendre. Pour en savoir plus sur l’utilisation de l’écran OLED avec les cartes ESP32 et ESP8266 à l’aide de MicroPython, reportez-vous aux tutoriels suivants :

Le code commence par importer les bibliothèques requises.

from machine import Pin, I2C
import ssd1306
from hcsr04 import HCSR04
from time import sleep

Réglez les broches de l’écran OLED et du capteur à ultrasons.

i2c = I2C(scl=Pin(5), sda=Pin(4))
sensor = HCSR04(trigger_pin=12, echo_pin=14, echo_timeout_us=10000)

Définissez la largeur et la hauteur de l’OLED et initialisez l’affichage OLED.

oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

Sur le tandis que boucle est l’endroit où nous obtiendrons la distance et l’afficherons sur l’OLED.

Tout d’abord, effacez l’affichage à chaque itération avec oled.fill(0).

oled.fill(0)

Obtenez la distance en mm et enregistrez-la dans le distance variable.

distance = sensor.distance_mm()

Imprimez la distance dans la console.

print('Distance:', distance, 'mm')

Affichez la distance sur l’écran. Notez que vous devez convertir la distance en une chaîne en utilisant le str() une fonction.

oled.text("Distance (mm)", 0, 15)
oled.text(str(distance), 0, 35)

Enfin, appelez oled.show() pour afficher réellement le texte.

oled.show()

La distance est mise à jour toutes les secondes.

sleep(1)

Manifestation

Téléchargez tous les fichiers précédents sur votre carte ESP32 ou ESP8266 dans l’ordre suivant :

1. ssd1306.py
2. hcsr04.py
3. main.py

Si vous ne savez pas comment télécharger du code, vous pouvez lire nos guides de démarrage avec uPyCraft IDE, Thonny IDE ou VS Code + PyMakr :

Après avoir téléchargé le code, il devrait commencer à fonctionner et affichera la distance en mm sur l’écran OLED, comme le montre l’image suivante.

Conclusion

Nous espérons que vous avez trouvé ce tutoriel utile. Nous avons plus de projets et de tutoriels avec MicroPython avec d’autres capteurs populaires que vous pourriez aimer :

Vous pouvez consulter tous nos projets MicroPython ici.

Si vous souhaitez en savoir plus sur la programmation des cartes ESP32 et ESP8266 avec MicroPython, accédez à notre eBook : Programmation MicroPython avec ESP32 et ESP8266.

Merci d’avoir lu.