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

Arduino UNO 08-01-24

285 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 LCD I2C 1602 et les boutons poussoirs

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

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 LCD I2C 1602 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 LCD I2C 1602.

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 LCD I2C 1602 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 LCD I2C 1602 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 LCD I2C 1602 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 LCD I2C 1602 :

Cet écran LCD est souvent utilisé dans divers projets électroniques pour afficher des informations textuelles telles que des messages, des valeurs de capteurs, des menus, des données de contrôle, etc

L’afficheur LCD I2C 1602 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 LCD I2C 1602 et les boutons poussoirs

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

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

1- Pour l’afficheur LCD I2C 1602

– Connecter la broche GND de l’afficheur LCD I2C 1602 à la broche GND de la carte ESP32

– Connecter la broche VCC de l’afficheur LCD I2C 1602 à la broche 5V de la carte ESP32

– Connecter la broche SDA de l’afficheur LCD I2C 1602 à la broche GPIO21 de la carte ESP32

– Connecter la broche SCL de l’afficheur LCD I2C 1602 à 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 Micropython pour démarrer et afficher le chronomètre sur un afficheur LCD I2C 1602

Assurez-vous d’avoir le firmware Micropython esp32-20210902-v1.17.bin installé sur votre ESP32 et les bibliothèques nécessaires (“i2c_lcd” et “lcd_api“) 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 l’écran LCD I2C 1602, démarre un chronomètre lorsqu’il est exécuté et affiche le temps écoulé sur l’écran LCD.

import machine
from machine import Pin, SoftI2C
import time

from lcd_api import LcdApi
from i2c_lcd import I2cLcd

I2C_ADDR = 0x27
totalRows = 2
totalColumns = 16
# Configurer les broches I2C (adapter SDA et SCL à vos broches ESP32)
i2c = SoftI2C(scl=Pin(22), sda=Pin(21), freq=10000)    
lcd = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)
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
lcd.putstr("Start Chrono")
lcd.move_to(0,1)
lcd.putstr("00:00") 

while True:
  # Si on appuie sur le bouton Start
  if (start_button.value() == False):
    lcd.clear()
    
    running = not running
    if (running):
        lcd.putstr("Chrono Running")
    else:
        lcd.clear()
        lcd.putstr("Chrono stopped")
        lcd.move_to(0,1)
         #afficher le temps ecoule sur l'afficheur LCD
        if (second<10):
          lcd.putstr(str(minute)+":0"+str(second))
        else:
          lcd.putstr(str(minute)+":"+str(second))

    print("status:"+str(running))
    time.sleep(0.5)
  # Si on appuie sur le bouton Reset  
  if (reset_button.value() == False):
      print("Reset")
      timer=0
      second=0
      minute=0
      lcd.clear()
      lcd.putstr("Chrono stopped")
      lcd.move_to(0,1)
       #afficher 00;00 sur l'afficheur LCD
      lcd.putstr("00:00") 
      time.sleep(0.5)
      running=False
      
  if (running):
    # Calculer le temps ecoule
    second += 1
    time.sleep(0.01)
    if (second == 60):
        second = 0
        minute += 1
    if (minute == 60):
        minute = 0
    lcd.move_to(0,1)
    #afficher le temps ecoule sur l'afficheur LCD
    if (second<10):
     lcd.putstr(str(minute)+":0"+str(second))
    else:
     lcd.putstr(str(minute)+":"+str(second))