Réalisation d’un chronomètre avec la carte ESP32 et l’afficheur SSD1306

ESP32 07-01-24

416 0

Plan du tutorial

1- Fonctionnement du chronomètre contrôlé par la carte ESP32

2- Les composants nécessaires pour construire un chronomètre commandé par la carte ESP32

3- Schéma de câblage de la carte ESP32 avec l'afficheur SSD1306 et les boutons poussoirs

4- Programmation de la carte ESP32 avec le Micropython pour démarrer et afficher le chronomètre sur un afficheur SSD1306

Fonctionnement du chronomètre contrôlé par la carte ESP32

Un chronomètre est un instrument de mesure du temps utilisé pour mesurer des intervalles de temps précis. Contrairement à une montre qui indique l'heure, un chronomètre est conçu pour mesurer des durées spécifiques, comme les courses, les compétitions sportives ou d'autres événements nécessitant une précision temporelle. Les chronomètres peuvent être analogiques ou numériques et sont souvent équipés de fonctionnalités telles que des compteurs, des arrêts et des redémarrages rapides pour permettre une mesure précise du temps écoulé.

Un chronomètre peut être créé en utilisant la carte ESP32 pour mesurer le temps écoulé entre différents événements ou pour chronométrer des intervalles spécifiques.

Le fonctionnement du chronomètre contrôlé par la carte ESP32 avec un afficheur SSD1306 et des boutons-poussoirs peut être décrit comme suit :

Démarrage initial : Lorsque vous alimentezla carte ESP32, le chronomètre commence à afficher Press START sur l'afficheur SSD1306.

Bouton de démarrage (Start) : En appuyant sur le bouton de démarrage, le chronomètre démarre en commençant à mesurer le temps écoulé depuis 00:00 jusqu'à ce que vous appuyiez sur le bouton d'arrêt.

Lorsque le chronomètre est en marche, l'afficheur SSD1306 montre le temps qui s'écoule en minutes et secondes, par exemple, 00:15 (15 secondes écoulées), 01:30 (1 minute et 30 secondes), etc.

En appuyant à nouveau sur le bouton Start, le chronomètre se fige, enregistrant le temps écoulé jusqu'à ce moment-là, sans le mettre à zéro.

Bouton Reset : En appuyant sur le bouton de réinitialisation, le chronomètre revient à 00:00, remettant ainsi le temps écoulé à zéro, peu importe son état précédent (en cours ou arrêté).

Ce fonctionnement vous permet de contrôler le chronomètre à l'aide des boutons-poussoirs : démarrer pour lancer la mesure du temps, arrêter pour geler le temps actuel et réinitialiser pour remettre le chronomètre à zéro. L'afficheur SSD1306 affiche en temps réel le temps écoulé au format minutes:secondes pendant que le chronomètre est en marche.

Les composants nécessaires pour construire un chronomètre commandé par la carte ESP32

Pour créer un chronomètre contrôlé par la carte ESP32, utilisant des boutons-poussoirs pour démarrer, arrêter et réinitialiser le chronomètre, avec un afficheur SSD1306 utilisant le protocole I2C, on a besoin de ces composants :

Carte ESP32 :

Carte ESP32

L'ESP32 est un microcontrôleur à faible consommation d'énergie, doté de fonctionnalités Wi-Fi et Bluetooth intégrées. Il est largement utilisé dans le domaine de l'IoT (Internet des Objets), du développement de projets embarqués et dans d'autres applications nécessitant une connectivité sans fil et un traitement de données sur une petite échelle.

Afficheur SSD1306 :

L'afficheur SSD1306 est un écran à cristaux liquides (LCD) de petite taille souvent utilisé dans les projets électroniques. Il utilise une technologie OLED (Organic Light Emitting Diode) pour produire des images en émettant leur propre lumière, ce qui lui permet d'être visible même dans des conditions de faible luminosité. Le SSD1306 est contrôlé par des microcontrôleurs ou des cartes de développement comme la carte ESP32.

L'afficheur SSD1306 est utilisé pour afficher le temps écoulé.

Deux boutons-poussoirs :

bouton-poussoir

Un bouton poussoir pour démarrer et arrêter

Un autre bouton pour réinitialiser le chronomètre.

Plaque d'essai (Breadboard) :

plaque d'essai

On utilise le plaque d'essai pour faciliter le câblage des différents composants.

Câbles de raccordement (jumpers) :

Fils de connexion

Pour connecter les différents composants entre eux.

Schéma de câblage de la carte ESP32 avec l'afficheur SSD1306 et les boutons poussoirs

Pour réaliser le câblage de la carte ESP32 avec un afficheur SSD1306 et des boutons-poussoirs pour un chronomètre on va suivre ces étapes :

1- Pour l'afficheur SSD1306

- Connecter la broche GND de l'afficheur SSD1306 à la broche GND de la carte ESP32

- Connecter la broche VCC de l'afficheur SSD1306 à la broche 3.3V de la carte ESP32

- Connecter la broche SDA de l'afficheur SSD1306 à la broche GPIO21 de la carte ESP32

- Connecter la broche SCL de l'afficheur SSD1306 à la broche GPIO22 de la carte ESP32

2- Pour le bouton poussoir Start

- Connecter l'une des pattes du bouton poussoir à la broche GPIO19 de la carte ESP32

- Connecter une autre patte du bouton poussoir à la broche GND de la carte ESP32

3- Pour le bouton poussoir Reset

- Connecter l'une des pattes du bouton poussoir à la broche GPIO18 de la carte ESP32

- Connecter une autre patte du bouton poussoir à la broche GND de la carte ESP32

Programmation de la carte ESP32 avec le Micropython pour démarrer et afficher le chronomètre sur un afficheur SSD1306

Assurez-vous d'avoir le firmware Micropython installé sur votre ESP32 et les bibliothèques nécessaires (comme ssd1306.py) installées sur votre carte avant d'exécuter ce code. De plus, ajustez les broches SCL et SDA (Pin(22) et Pin(21)) en fonction du câblage réel de votre ESP32.

Ce code initialise un écran SSD1306, démarre un chronomètre lorsqu'il est exécuté et affiche le temps écoulé sur l'écran OLED.

import machine
from machine import Pin
import time
from machine import Pin, I2C
import ssd1306

# Configuration des broches pour l'afficheur SSD1306
# Définir les broches SCL et SDA appropriées
i2c = I2C(-1, scl=Pin(22), sda=Pin(21))
# Définir la résolution de votre écran
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

start_button= machine.Pin(19, machine.Pin.IN, machine.Pin.PULL_UP)
reset_button = machine.Pin(18, machine.Pin.IN, machine.Pin.PULL_UP)

start_state=0;
reset_state=0;
running=False;
timer=0
second=0
minute=0
oled.text('Start Chrono', 0, 0)
oled.text('00:00', 0, 20)
oled.show()

while True:
  #Si on appuie sur le bouton Start
  if (start_button.value() == False):
    running = not running
    print("status:"+str(running))
    if (running==False):
        oled.fill(0)
        oled.text('Chrono stopped', 0, 0)
        oled.text(str(minute)+':'+str(second), 0, 20)
        oled.show() 
    time.sleep(0.5)
  #Si on appuie sur le bouton Reset 
  if (reset_button.value() == False):
      print("Reset")
      timer=0
      second=0
      minute=0
      #effacer le contenu de l'afficheur
      oled.fill(0)
      #afficher sur l'afficheur SSD1306
      oled.text('Start Chrono', 0, 0)
      oled.text('00:00', 0, 20)
      oled.show() # Mettre à jour l'affichage
      time.sleep(0.5)
      running=False
      
  if (running):
    second += 1
    time.sleep(0.01)
    if (second == 60):
        second = 0
        minute += 1
    if (minute == 60):
        minute = 0
    oled.fill(0)
    oled.text('Chrono running', 0, 0)
    # Afficher le temps
    oled.text(str(minute)+':'+str(second), 0, 20)
    oled.show() # Mettre à jour l'affichage