Projet ESP9266 NodeMCU : distributeur de monnaie intelligent

ESP8266 02-04-26

10 0

Plan de tutoriel

1- Présentation du projet

2- Matériel nécessaire

3- Schéma de câblage du distributeur de pièces

4- Programmation de la carte ESP8266

Présentation du projet

Le distributeur de monnaie intelligent basé sur une carte ESP8266 NodeMCU a pour objectif principal d’automatiser la distribution de pièces de manière précise et contrôlée. Il permet à l’utilisateur de sélectionner un montant à l’aide de deux boutons poussoirs, tout en affichant en temps réel les informations nécessaires sur un afficheur LCD I2C. Ce type de système vise à simplifier les opérations de distribution, réduire les erreurs humaines et servir de support pédagogique pour les projets d’électronique embarquée.

Au démarrage, le système initialise les différents périphériques. L’ESP8266 configure la communication I2C pour piloter l’écran LCD, initialise les entrées numériques pour les boutons poussoirs et prépare la sortie PWM destinée au servomoteur. Une fois cette phase terminée, un message d’accueil ou d’instruction s’affiche sur l’écran, indiquant à l’utilisateur qu’il peut commencer la sélection du montant.

L’interaction utilisateur se fait à travers les deux boutons poussoirs. Le premier bouton permet d’augmenter progressivement le montant à distribuer, tandis que le second sert à valider ce choix. À chaque appui, le montant sélectionné est mis à jour et affiché sur le LCD, offrant ainsi un retour visuel clair et immédiat. Cette approche garantit une utilisation simple et intuitive, même pour un utilisateur non expérimenté.

Une fois le montant validé, le système calcule le nombre de pièces nécessaires en fonction de la valeur unitaire des pièces disponibles dans le distributeur. L’ESP8266 envoie alors des signaux de commande au servomoteur, qui actionne un mécanisme mécanique permettant de libérer les pièces une par une. Chaque mouvement du servomoteur correspond à la distribution d’une pièce, assurant ainsi une précision dans le comptage.

Pendant toute la phase de distribution, l’afficheur LCD indique l’état du système, par exemple le nombre de pièces restantes à distribuer ou un message de progression. Une fois la distribution terminée, un message de confirmation s’affiche, et le système revient automatiquement à l’état initial, prêt pour une nouvelle

Matériel nécessaire

1- Carte ESP8266

La carte ESP8266 NodeMCU constitue l’unité centrale du système. Elle assure le traitement des données, la gestion des entrées/sorties et l’exécution du programme principal. Grâce à son microcontrôleur intégré, elle lit les états des boutons poussoirs, communique avec l’afficheur LCD via le protocole I2C et génère un signal PWM pour piloter le servomoteur.

2- Boutons poussoirs (2 pièces)

bouton-poussoir

Les boutons poussoirs sont utilisés comme interface utilisateur. Ils permettent d’interagir avec le système de manière simple et directe. Le premier bouton est généralement dédié à l’incrémentation du montant, tandis que le second sert à valider la sélection. Chaque bouton est connecté à une entrée numérique de la carte, souvent avec une résistance de tirage (pull-up ou pull-down) pour garantir un état logique stable.

3. Servomoteur

Le servomoteur est l’élément chargé de la partie mécanique du système. Il permet de contrôler précisément un mécanisme de distribution des pièces.

4. Afficheur LCD I2C

L’afficheur LCD I2C est utilisé pour afficher les informations du système.

5. Mécanisme mécanique du distributeur

Le mécanisme du distributeur de pièces est la partie mécanique qui permet de libérer une pièce à la fois.

Rôle dans le projet :

- stocker les pièces

- permettre leur distribution contrôlée une par une

6. Câbles de Connexion (Jumper Wires)

Fils de connexion

Les fils de connexion permettent de relier les différents composants entre eux.

7- Breadboard (Plaque d'essai) :

plaque d'essai

Une breadboard est utile pour créer un circuit temporaire et connecter facilement les composants entre eux.

8- Module d'alimentation :

Module d'alimentation

Ce module se connecte généralement à une plaque d’essai (breadboard) et permet d’alimenter différents composants électroniques tels que les servomoteurs. Il reçoit l’alimentation à partir d’une source externe (adaptateur, batterie ou port USB) et régule la tension pour fournir du 5V ou du 3.3V selon les besoins du circuit.

9- Batterie de 9V

La batterie de 9V sert de source d’énergie pour le module d’alimentation. Elle fournit une tension de 9 volts qui est ensuite régulée par le module afin d’obtenir des tensions plus adaptées aux circuits électroniques, généralement 5V ou 3,3V.

Schéma de câblage du distributeur de pièces

1- Connexion du bouton 1 à la carte ESP8266

Bouton 1	Carte ESP8266
Patte	Pin 14 (D5)
Autre patte	GND

2- Connexion du bouton 2 à la carte ESP8266

Bouton 2	Carte ESP8266
Patte	Pin 12 (D6)
Autre patte	GND

3- Connexion du servomoteur à la carte ESP8266

Servomoteur	Carte ESP8266
Fil rouge	5V du module d'alimentation
Fil marron	GND
Fil jaune	Pin 13 (D7)

4- Connexion de l’afficheur LCD I2C à la carte ESP8266

Afficheur LCD I2C	Carte ESP8266
VCC	5V
GND	GND
SDA	Pin 5 (D2)
SCL	Pin 4 (D1)

Programmation de la carte ESP8266

Ce programme permet de contrôler un distributeur de pièces automatisé basé sur la carte ESP8266 NodeMCU, utilisant :

- deux boutons poussoirs pour ajouter du crédit ou lancer la distribution.

- un servomoteur pour actionner le mécanisme de poussée des pièces.

- Un écran LCD I2C pour afficher le montant actuel ou les messages pour l’utilisateur.

Le programme suit une logique simple : ajouter du crédit → afficher le montant → distribuer les pièces → remettre le compteur à zéro.

On commence par l’importation de ces bibliothèques:

i2c_lcd et lcd_api → pour afficher les informations sur l’écran LCD I2C

Servo → pour commander le servomoteur

Voici le code en Micropython qui implémente le fonctionnement du système :

from time import sleep
from machine import Pin, I2C, SoftI2C
from servo import Servo

# Importation de la bibliothèque pour contrôler l'afficheur LCD I2C
from i2c_lcd import I2cLcd


I2C_ADDR = 0x27

I2C_ADDR = 0x27
totalRows = 4
totalColumns = 20

# === Initialisation du LCD I2C ===
i2c = SoftI2C(scl=Pin(5), sda=Pin(4), freq=10000)  
# Initialisation de la communication I2C pour ESP8266

lcd = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)

# Effacer l'écran LCD
lcd.clear()

# Affichage des messages initiaux
lcd.move_to(0, 0)
lcd.putstr("Distributeur ESP8266")

lcd.move_to(0, 1)
lcd.putstr("Montant a retirer")

lcd.move_to(0, 2)
lcd.putstr("4000")

montant = 0

# Configuration des boutons poussoirs avec résistance de tirage interne (pull-up)
button_1 = Pin(14, Pin.IN, Pin.PULL_UP)
button_2 = Pin(12, Pin.IN, Pin.PULL_UP)

# Initialisation du servomoteur (broche GPIO13)
servo_motor = Servo(pin=13)  
servo_motor.move(0)  # Position initiale à 0°

# Test initial du servomoteur (mouvement aller-retour)
for i in range(2):
    servo_motor.move(150)  # Rotation vers position d'ouverture
    sleep(0.5)
    servo_motor.move(0)    # Retour à la position initiale
    sleep(0.5)

while True:
    
    # Si le bouton 1 est appuyé → augmenter le montant
    if button_1.value() == 0:
        montant = montant + 1000
        
        lcd.move_to(0, 2)
        lcd.putstr(str(montant))
    
    # Si le bouton 2 est appuyé → valider et distribuer
    if button_2.value() == 0:
        print("Bouton 2 appuye")
        
        # Distribution des pièces selon le montant
        for i in range(montant // 1000):
            servo_motor.move(150)  # Libérer une pièce
            sleep(0.5)
            servo_motor.move(0)    # Revenir en position de blocage
            sleep(0.5)
        
        # Réinitialisation du montant après distribution
        montant = 0
        
        lcd.move_to(0, 2)
        lcd.putstr(str(montant))
    
    sleep(0.3)