Système de traduction et d'apprentissage du Braille

Objet qui permet de traduire et d'apprendre le braille.

Difficulté

Hard Difficile

Durée

72 hour(s) heure(s)

Catégories

Électronique, Bien-être & Santé

Coût

250 EUR (€)

aveugles, Braille, Traduction, Apprentissage Syst_me_de_traduction_et_d_apprentissage_du_Braille_20250526_144220_1_.jpg Creation

Introduction

Présentation d'un tutoriel notre projet de classe de terminale STI2D afin de le reproduire chez soi

1. 
2. 
3. 
4. 
5. 
6. 

Matériaux

-Bois 3mm

-Plastique pour découpeuse laser ( ici du PLA)

Outils

-Découpeuse laser

-Imprimante 3D (ici la Ultimaker 2+)

Étape 1 - Découpe des pièces en bois du boitier

-Connecter l'ordinateur à la découpeuse laser

-Ouvrir le logiciel Trotek ( Nécessaire à la découpe)

-Ouvrir les pièces à découper en format dxf dans le logiciel

-Optimiser l'espace sur la planche afin d'avoir les moins de perte de matière et déplaçant les pièces

-Lancer la découpe

-Nettoyer les pièces afin d'éviter des tâches dues au bois brûlé.

Étape 2 - Assemblage des pièces en bois

Étape 3 -

Étape 4 -

Étape 5 - Branchement entre les carte électroniques et les servo-moteurs

-Assurez vous d'avoir une Raspberry Pi configurer avant de commencer

w ====- Brancher les servo moteur sur la carte arduino - inséré le code

</syntaxhighlight> - Se munir de la carte raspery Pi - Brancher relier les broches Gpio raspery Pi avec celle de arduino(gnd,vcc) taper sur internet broche raspery pi - inséré ce code

import smbus
import time
import RPi.GPIO as GPIO  
import random
import os  
import threading
import cv2
import pytesseract
import numpy as np

I2C_ADDR = 8  
bus = smbus.SMBus(1)  

# GPIO des boutons
BOUTON_PRECEDENT = 17  
BOUTON_SUIVANT = 27    
BOUTON_LECON = 23  
BOUTON_EXERCICE = 24
BOUTON_CAMERA = 22  # Bouton pour la caméra

# GPIO du capteur ultrason HCSR04
TRIG = 5  # GPIO pour le trigger du capteur
ECHO = 6  # GPIO pour l'echo du capteur

# Configuration des GPIO
try:
    GPIO.cleanup()
except:
    pass

GPIO.setmode(GPIO.BCM)
GPIO.setup(BOUTON_PRECEDENT, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(BOUTON_SUIVANT, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(BOUTON_LECON, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(BOUTON_EXERCICE, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(BOUTON_CAMERA, GPIO.IN, pull_up_down=GPIO.PUD_UP)

# Configuration du capteur ultrason
GPIO.setup(TRIG, GPIO.OUT)
GPIO.setup(ECHO, GPIO.IN)
GPIO.output(TRIG, False)  # S'assurer que le trigger est bas au démarrage

# Dictionnaire Braille
braille_dict = {
    "a": 0b100000, "b": 0b110000, "c": 0b101000, "d": 0b101100,
    "e": 0b100100, "f": 0b111000, "g": 0b111100, "h": 0b110100,
    "i": 0b011000, "j": 0b011100, "k": 0b100010, "l": 0b110010,
    "m": 0b101010, "n": 0b101110, "o": 0b100110, "p": 0b111010,
    "q": 0b111110, "r": 0b110110, "s": 0b011010, "t": 0b011110,
    "u": 0b100011, "v": 0b110011, "w": 0b011101, "x": 0b101011,
    "y": 0b101111, "z": 0b100111, " ": 0b000000
}

texte = "bonjour"  # Texte par défaut
index = 0
lecon_en_cours = False
exercice_en_cours = False
attente_texte = False  # Pour savoir si on attend une saisie de texte
camera_en_cours = False  # Pour indiquer si une capture par caméra est en cours

# Paramètres de capture d'image
IMAGE_PATH = "capture.jpg"
CROPPED_PATH = "cropped.jpg"
DISTANCE_OPTIMALE = 15  # Distance optimale en cm
MARGE_DISTANCE = 2.5    # Marge de tolérance en cm (+/-)

def mesurer_distance():
    """Mesure la distance avec le capteur ultrason HCSR04."""
    # Envoyer une impulsion de 10µs au trigger
    GPIO.output(TRIG, True)
    time.sleep(0.00001)  # 10µs
    GPIO.output(TRIG, False)
    
    # Attendre que l'écho commence
    start_time = time.time()
    timeout = start_time + 1.0  # Timeout de 1 seconde
    
    while GPIO.input(ECHO) == 0:
        if time.time() > timeout:
            return -1  # Erreur: pas de signal
        pulse_start = time.time()
    
    # Attendre que l'écho se termine
    while GPIO.input(ECHO) == 1:
        if time.time() > timeout:
            return -1  # Erreur: signal trop long
        pulse_end = time.time()
    
    # Calculer la durée de l'impulsion
    pulse_duration = pulse_end - pulse_start
    
    # Calculer la distance (vitesse du son = 34300 cm/s)
    # Diviser par 2 car le signal fait l'aller-retour
    distance = (pulse_duration * 34300) / 2
    
    return round(distance, 1)  # Arrondir à 1 décimale

def guide_position():
    """Guide l'utilisateur pour positionner correctement le texte."""
    global camera_en_cours
    
    print("📏 Positionnement du texte...")
    os.system('espeak -v fr "Positionnez le texte" --stdout | aplay')
    
    # Attendre que la distance soit stable dans la plage optimale
    position_stable = False
    nb_mesures_stables = 0
    
    while camera_en_cours and not position_stable:
        distance = mesurer_distance()
        
        if distance < 0:
            print("⚠️ Erreur de mesure de distance")
            time.sleep(0.5)
            continue
            
        print(f"📏 Distance mesurée : {distance} cm")
        
        if distance < DISTANCE_OPTIMALE - MARGE_DISTANCE:
            # Trop proche
            os.system('espeak -v fr "Reculez" --stdout | aplay')
            nb_mesures_stables = 0
        elif distance > DISTANCE_OPTIMALE + MARGE_DISTANCE:
            # Trop loin
            os.system('espeak -v fr "Avancez" --stdout | aplay')
            nb_mesures_stables = 0
        else:
            # Distance correcte
            print(f"✅ Distance correcte : {distance} cm")
            nb_mesures_stables += 1
            
            # Si 3 mesures consécutives sont dans la plage, on considère la position comme stable
            if nb_mesures_stables >= 3:
                position_stable = True
                os.system('espeak -v fr "Position correcte" --stdout | aplay')
        
        time.sleep(0.5)  # Attendre avant la prochaine mesure
    
    return position_stable

def envoyer_nombre(nombre, mode=None):
    """Envoie une lettre en Braille et annonce (avec délai optionnel en mode exercice)."""
    try:
        lettre = [key for key, val in braille_dict.items() if val == nombre][0]  
        bus.write_byte(I2C_ADDR, nombre)
        print(f"✅ Lettre envoyée: {lettre.upper()} ({bin(nombre)})")
        
        # Si c'est le mode exercice, attendre 2 secondes avant d'énoncer la lettre
        if mode == "exercice":
            # Vérifier périodiquement si l'exercice a été arrêté pendant l'attente
            debut = time.time()
            while time.time() - debut < 2 and exercice_en_cours:
                time.sleep(0.1)
            
            # Ne prononcer la lettre que si l'exercice est toujours en cours
            if exercice_en_cours:
                os.system(f'espeak -v fr "{lettre}" --stdout | aplay')
        else:
            # Pour les autres modes, énoncer la lettre immédiatement
            os.system(f'espeak -v fr "{lettre}" --stdout | aplay')  
    except IOError:
        print("❌ Erreur de communication avec l'Arduino")
    except IndexError:
        print("❌ Erreur: code braille non trouvé dans le dictionnaire")
    except Exception as e:
        print(f"❌ Erreur inattendue: {str(e)}")

def demander_nouveau_texte():
    """Demande un nouveau texte et réinitialise l'index."""
    global texte, index, attente_texte
    
    # Annonce vocale
    os.system('espeak -v fr "Entrez un nouveau texte" --stdout | aplay')
    
    # Lancer un thread pour attendre la saisie sans bloquer le reste du programme
    def attendre_saisie():
        global texte, index, attente_texte
        nouveau_texte = input("\n🆕 Entrez un texte (ou appuyez sur Entrée pour garder 'bonjour') : ").lower()
        if nouveau_texte:  # Si l'utilisateur a entré quelque chose
            texte = nouveau_texte
        index = 0
        print(f"🔠 Texte actuel : {texte}")
        print("📌 Appuyez sur le bouton 'Suivant' pour parcourir le texte, ou sur 'Leçon'/'Exercice' pour ces modes.")
        attente_texte = False  # Fin de l'attente
    
    attente_texte = True  # Début de l'attente
    t = threading.Thread(target=attendre_saisie)
    t.daemon = True
    t.start()

def bouton_precedent(channel):
    """Affiche la lettre précédente pendant la lecture du texte."""
    global index
    
    # Ne pas exécuter si un mode est en cours ou si on attend une saisie
    if lecon_en_cours or exercice_en_cours or attente_texte or camera_en_cours:
        return
    
    time.sleep(0.2)  # Anti-rebond
    if GPIO.input(BOUTON_PRECEDENT) == GPIO.LOW:
        if index > 0:
            index -= 1
            envoyer_nombre(braille_dict.get(texte[index], 0))
            print(f"🔙 Lettre précédente: {texte[index]}")
        else:
            print("🚫 Déjà à la première lettre.")
            os.system('espeak -v fr "Première lettre" --stdout | aplay')

def bouton_suivant(channel):
    """Affiche la lettre suivante et lit le mot en entier à la fin."""
    global index
    
    # Ne pas exécuter si un mode est en cours ou si on attend une saisie
    if lecon_en_cours or exercice_en_cours or attente_texte or camera_en_cours:
        return
    
    time.sleep(0.2)  # Anti-rebond
    if GPIO.input(BOUTON_SUIVANT) == GPIO.LOW:
        if texte and index < len(texte):
            envoyer_nombre(braille_dict.get(texte[index], 0))
            index += 1
            print(f"🔜 Lettre suivante: {texte[index-1]}")
            if index == len(texte):
                print("🔁 Fin du texte, lecture complète...")
                os.system(f'espeak -v fr "{texte}" --stdout | aplay')
                demander_nouveau_texte()

def lancer_lecon():
    """Fonction pour lancer la leçon dans un thread séparé."""
    global lecon_en_cours
    
    # Si on attend une saisie de texte, annuler cette attente
    global attente_texte
    attente_texte = False
    
    # Marquer le début de la leçon
    lecon_en_cours = True
    print("📖 Début de la leçon...")
    os.system('espeak -v fr "Début de la leçon" --stdout | aplay')
    
    # Parcourir l'alphabet
    for lettre in "abcdefghijklmnopqrstuvwxyz":
        # Vérifier si la leçon a été arrêtée
        if not lecon_en_cours:
            return
        
        # Afficher et annoncer la lettre
        print(f"📝 Leçon : Lettre {lettre.upper()}")
        envoyer_nombre(braille_dict[lettre])
        
        # Attendre 8 secondes, en vérifiant si la leçon a été arrêtée
        debut = time.time()
        while time.time() - debut < 8:
            if not lecon_en_cours:
                return  # Sortir immédiatement si la leçon a été arrêtée
            time.sleep(0.1)
    
    # Fin normale de la leçon
    print("✅ Leçon terminée !")
    os.system('espeak -v fr "Leçon terminée" --stdout | aplay')
    lecon_en_cours = False
    
    # Proposer d'entrer un nouveau texte sans bloquer
    demander_nouveau_texte()

def lancer_exercice():
    """Fonction pour lancer l'exercice dans un thread séparé."""
    global exercice_en_cours
    
    # Si on attend une saisie de texte, annuler cette attente
    global attente_texte
    attente_texte = False
    
    # Marquer le début de l'exercice
    exercice_en_cours = True
    print("🎲 Début de l'exercice...")
    os.system('espeak -v fr "Début de l\'exercice" --stdout | aplay')
    
    # Préparer les lettres dans un ordre aléatoire
    lettres = list("abcdefghijklmnopqrstuvwxyz")
    random.shuffle(lettres)
    
    # Parcourir les lettres aléatoires
    for lettre in lettres:
        # Vérifier si l'exercice a été arrêté
        if not exercice_en_cours:
            return
        
        # Afficher et annoncer la lettre avec délai de 2 secondes
        print(f"📝 Exercice : Lettre {lettre.upper()}")
        envoyer_nombre(braille_dict[lettre], mode="exercice")
        
        # Attendre le reste des 8 secondes (moins les 2 secondes d'attente déjà écoulées), 
        # en vérifiant si l'exercice a été arrêté
        debut = time.time()
        while time.time() - debut < 6:  # 8 - 2 = 6 secondes restantes
            if not exercice_en_cours:
                return  # Sortir immédiatement si l'exercice a été arrêté
            time.sleep(0.1)
    
    # Fin normale de l'exercice
    print("🏆 Exercice terminé !")
    os.system('espeak -v fr "Exercice terminé" --stdout | aplay')
    exercice_en_cours = False
    
    # Proposer d'entrer un nouveau texte sans bloquer
    demander_nouveau_texte()

def capturer_et_lire_texte():
    """Fonction pour capturer une image avec la caméra et en extraire le texte."""
    global camera_en_cours, texte, index, attente_texte
    
    # Si on attend une saisie de texte, annuler cette attente
    attente_texte = False
    
    # Marquer le début de la capture
    camera_en_cours = True
    print("📸 Préparation de la capture...")
    os.system('espeak -v fr "Préparation de la capture" --stdout | aplay')
    
    # Guide de positionnement avec le capteur ultrason
    if guide_position():
        # Capture de l'image (réduction du temps à 3s car on a déjà guidé l'utilisateur)
        print("📸 Capture en cours...")
        os.system('espeak -v fr "Capture en cours" --stdout | aplay')
        os.system(f"libcamera-jpeg -o {IMAGE_PATH} -t 3000 --width 1920 --height 1080 --quality 100")
        
        # Vérifier si l'image existe
        if not os.path.exists(IMAGE_PATH):
            print("❌ Erreur : L'image n'a pas été capturée.")
            os.system('espeak -v fr "Erreur de capture" --stdout | aplay')
            camera_en_cours = False
            return
        
        print("⚡ Optimisation de l'image...")
        try:
            # Chargement et conversion en niveaux de gris
            image = cv2.imread(IMAGE_PATH)
            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
            
            # Correction de l'orientation
            try:
                osd = pytesseract.image_to_osd(gray)
                angle = int(osd.split("\n")[1].split(":")[1].strip())
                if angle != 0:
                    (h, w) = gray.shape[:2]
                    center = (w // 2, h // 2)
                    M = cv2.getRotationMatrix2D(center, -angle, 1.0)
                    gray = cv2.warpAffine(gray, M, (w, h))
            except:
                print("⚠ Impossible de détecter l'orientation, passage à l'étape suivante.")
            
            # Prétraitement (amélioration du contraste et du bruit)
            gray = cv2.GaussianBlur(gray, (3, 3), 0)
            gray = cv2.equalizeHist(gray)  # Augmentation du contraste
            gray = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 31, 10)
            
            # Détection des contours pour recadrer uniquement le texte
            print("📐 Détection du texte...")
            edges = cv2.Canny(gray, 50, 150)
            contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
            
            filtered_contours = [c for c in contours if cv2.contourArea(c) > 1000]
            
            if filtered_contours:
                x, y, w, h = cv2.boundingRect(cv2.convexHull(np.vstack(filtered_contours)))
                cropped = image[y:y+h, x:x+w]
                cropped = cv2.resize(cropped, None, fx=1.5, fy=1.5, interpolation=cv2.INTER_LINEAR)
                cv2.imwrite(CROPPED_PATH, cropped)
            else:
                print("⚠ Aucun texte clairement détecté, extraction sur l'image entière.")
                cropped = image
            
            # OCR optimisé
            print("🔍 Extraction du texte...")
            detected_text = pytesseract.image_to_string(cropped, lang="eng+fra", config="--psm 6 --oem 3").strip()
            
            # Nettoyer le texte détecté (supprimer les caractères spéciaux et garder lettres, chiffres et espaces)
            cleaned_text = ''.join(c.lower() for c in detected_text if c.isalnum() or c.isspace())
            
            # Si le texte est vide après nettoyage, afficher un message
            if not cleaned_text:
                print("⚠ Aucun texte détecté après nettoyage.")
                os.system('espeak -v fr "Aucun texte détecté" --stdout | aplay')
                camera_en_cours = False
                return
            
            # Afficher le texte détecté
            print(f"\n📄 Texte détecté : {cleaned_text}")
            os.system(f'espeak -v fr "Texte détecté" --stdout | aplay')
            
            # Mettre à jour le texte global et réinitialiser l'index
            texte = cleaned_text
            index = 0
            print(f"🔠 Nouveau texte : {texte}")
            print("📌 Appuyez sur le bouton 'Suivant' pour parcourir le texte.")
            
        except Exception as e:
            print(f"❌ Erreur lors du traitement de l'image : {str(e)}")
            os.system('espeak -v fr "Erreur de traitement" --stdout | aplay')
    else:
        print("❌ Positionnement annulé.")
        os.system('espeak -v fr "Positionnement annulé" --stdout | aplay')
    
    # Marquer la fin de la capture
    camera_en_cours = False

def bouton_lecon_presse(channel):
    """Fonction appelée lorsque le bouton leçon est pressé."""
    global lecon_en_cours
    
    # Ne pas réagir si un autre mode est en cours
    if exercice_en_cours or camera_en_cours:
        return
    
    time.sleep(0.2)  # Anti-rebond
    if GPIO.input(BOUTON_LECON) == GPIO.LOW:
        # Basculer l'état de la leçon
        if lecon_en_cours:
            lecon_en_cours = False
            print("📖 Leçon arrêtée par l'utilisateur.")
            os.system('espeak -v fr "Leçon arrêtée" --stdout | aplay')
            # La leçon est arrêtée, sera nettoyée dans le thread
        else:
            # Lancer la leçon dans un thread séparé
            t = threading.Thread(target=lancer_lecon)
            t.daemon = True  # Le thread s'arrêtera quand le programme principal s'arrête
            t.start()

def bouton_exercice_presse(channel):
    """Fonction appelée lorsque le bouton exercice est pressé."""
    global exercice_en_cours
    
    # Ne pas réagir si un autre mode est en cours
    if lecon_en_cours or camera_en_cours:
        return
    
    time.sleep(0.2)  # Anti-rebond
    if GPIO.input(BOUTON_EXERCICE) == GPIO.LOW:
        # Basculer l'état de l'exercice
        if exercice_en_cours:
            exercice_en_cours = False
            print("🎲 Exercice arrêté par l'utilisateur.")
            os.system('espeak -v fr "Exercice arrêté" --stdout | aplay')
            # L'exercice est arrêté, sera nettoyé dans le thread
        else:
            # Lancer l'exercice dans un thread séparé
            t = threading.Thread(target=lancer_exercice)
            t.daemon = True  # Le thread s'arrêtera quand le programme principal s'arrête
            t.start()

def bouton_camera_presse(channel):
    """Fonction appelée lorsque le bouton caméra est pressé."""
    global camera_en_cours
    
    # Ne pas réagir si un autre mode est en cours
    if lecon_en_cours or exercice_en_cours or camera_en_cours:
        return
    
    time.sleep(0.2)  # Anti-rebond
    if GPIO.input(BOUTON_CAMERA) == GPIO.LOW:
        # Lancer la capture dans un thread séparé
        t = threading.Thread(target=capturer_et_lire_texte)
        t.daemon = True  # Le thread s'arrêtera quand le programme principal s'arrête
        t.start()

# Supprimer les détecteurs d'événements existants s'il y en a
try:
    GPIO.remove_event_detect(BOUTON_SUIVANT)
    GPIO.remove_event_detect(BOUTON_PRECEDENT)
    GPIO.remove_event_detect(BOUTON_LECON)
    GPIO.remove_event_detect(BOUTON_EXERCICE)
    GPIO.remove_event_detect(BOUTON_CAMERA)
except:
    pass

# Configuration des détecteurs d'événements
GPIO.add_event_detect(BOUTON_SUIVANT, GPIO.FALLING, callback=bouton_suivant, bouncetime=500)
GPIO.add_event_detect(BOUTON_PRECEDENT, GPIO.FALLING, callback=bouton_precedent, bouncetime=500)
GPIO.add_event_detect(BOUTON_LECON, GPIO.FALLING, callback=bouton_lecon_presse, bouncetime=500)
GPIO.add_event_detect(BOUTON_EXERCICE, GPIO.FALLING, callback=bouton_exercice_presse, bouncetime=500)
GPIO.add_event_detect(BOUTON_CAMERA, GPIO.FALLING, callback=bouton_camera_presse, bouncetime=500)

# Initialisation du capteur ultrason (attendre qu'il se stabilise)
print("⚙️ Initialisation du capteur ultrason...")
time.sleep(0.5)
GPIO.output(TRIG, False)
time.sleep(0.5)

# Afficher les instructions au démarrage
print("👋 Bienvenue dans l'application d'apprentissage du Braille")
print("📋 Instructions:")
print("  - Bouton LEÇON: Apprendre l'alphabet (8s par lettre)")
print("  - Bouton EXERCICE: Pratiquer avec des lettres aléatoires (2s de réflexion, puis annonce)")
print("  - Bouton SUIVANT: Afficher la lettre suivante du texte")
print("  - Bouton PRÉCÉDENT: Afficher la lettre précédente du texte")
print("  - Bouton CAMÉRA: Guide le positionnement, puis capture une image et extrait le texte")
print("⚠️ Appuyez à nouveau sur LEÇON/EXERCICE pour arrêter à tout moment")
print(f"🔠 Texte par défaut : {texte}")
print("📌 Appuyez sur le bouton 'Suivant' pour parcourir le texte, ou choisissez un mode.")

# Boucle principale pour maintenir le programme actif
try:
    while True:
        time.sleep(0.1)
except KeyboardInterrupt:
    print("\n🛑 Arrêt du programme.")
    GPIO.cleanup()

- regardez un tuto pour crée un fichier pour inséré le code Raspberry Pi et l'executer et avant de lancer le fichier il faut crée un environment virtuel regardez un tuto pour ça aussi====

Étape 6 - Système d'interface homme-machine

Le système est équipé de 5 boutons physiques qui permettent de contrôler les différents modes d'apprentissage et la détection du texte.

-Brancher les bouton aux broches gpio correspondantes grâce au code inséré précédement

Étape 7 - Système de détection de texte

Le système utilise une caméra et un capteur à ultrasons pour détecter du texte .

-Se munir du Capteur ultrason et le brancher sur la broche gpio (regardez le code rasperypi pour savoir )

- Brancher la camera à la Raspberry Pi, il y a un tuto ici

-Lancer le code

Étape 8 -

fr none 0 Published