Discussion :

[Joe_M8]

Bonjour à tous,
Le but du projet est d'utiliser un téléphone à cadran S63 comme lecteur de mp3.


Matériel : téléphone S63, Raspberry Pi Zero W, DAC externe, Raspberry Pi OS Lite.

Fonctionnement :
1- au décroché dial-tone.mp3 est joué (fréquence 440Hz)
2- lorsque l'utilisateur compose un numéro, le son s'arrête et les impulsions créées par le cadran rotatif sont comptées pour connaitre le numéro saisi par l'utilisateur.
3- une fois les différents chiffres stockés, le numéro final sert de recherche de fichier mp3. Exemple si 42 est saisi le fichier 42_texteexemple.mp3 est joué.
4- juste avant la lecture de 42_texteexemple.mp3 le fichier recherche.mp3 est joué.
5- si le aucun fichier ne commence par 42 le fichier non2.mp3 est joué. L'utilisateur doit alors raccrocher pour recommencer.

Dans mon code l'étape 1 fonctionne, mais l'étape 2 ne fonctionne pas. Le fichier lis le fichier mp3 mais ne semble pas voir les numéros du cadran.


Voici le code avec toutes les fonctions :

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
import RPi.GPIO as GPIO
import pygame
import os
import time
from typing import Optional
 
# Constants for GPIO pins
GPIO_PIN_OFF_HOOK = 25  # Pin GPIO pour détecter si le téléphone est décroché
GPIO_PIN_DIAL = 17      # Pin GPIO pour lire les impulsions du cadran
 
# Configuration des GPIO
GPIO.setmode(GPIO.BCM)  # Utilisation du mode BCM pour la numérotation des GPIO
GPIO.setup(GPIO_PIN_OFF_HOOK, GPIO.IN, pull_up_down=GPIO.PUD_UP)  # Configuration du pin off-hook avec une résistance de pull-up
GPIO.setup(GPIO_PIN_DIAL, GPIO.IN, pull_up_down=GPIO.PUD_UP)      # Configuration du pin dial avec une résistance de pull-up
 
# Initialisation de pygame pour la lecture audio
pygame.mixer.init()
 
# Chemin du répertoire des sons
SOUND_DIR = "/home/user/sounds"
 
def play_sound(file: str) -> None:
    """Joue un fichier audio s'il existe."""
    if os.path.exists(file):
        print(f"Lecture du fichier : {file}")
        pygame.mixer.music.load(file)
        pygame.mixer.music.play()
        # Attendre que le fichier audio se termine ou que le téléphone soit raccroché
        while pygame.mixer.music.get_busy() and GPIO.input(GPIO_PIN_OFF_HOOK) == GPIO.LOW:
            time.sleep(0.1)
    else:
        print(f"Fichier {file} non trouvé.")
 
def stop_sound() -> None:
    """Arrête la lecture audio en cours."""
    if pygame.mixer.music.get_busy():
        print("Arrêt de la lecture audio.")
        pygame.mixer.music.stop()
 
def wait_for_off_hook() -> None:
    """Attend le signal de décroché et joue le son de la tonalité de numérotation."""
    print("En attente de décroché...")
    while GPIO.input(GPIO_PIN_OFF_HOOK):
        time.sleep(0.1)
    print("Décroché détecté.")
    play_sound(os.path.join(SOUND_DIR, "dial-tone_2.mp3"))
 
def read_dial() -> int:
    """Lit le nombre d'impulsions du cadran et retourne le chiffre correspondant."""
    dial_count = 0
    print("Lecture du cadran...")
 
    # Attendre le début de la première impulsion
    while GPIO.input(GPIO_PIN_DIAL) == GPIO.HIGH:
        time.sleep(0.01)
 
    # Lire les impulsions
    while True:
        # Attendre que le cadran soit relâché
        while GPIO.input(GPIO_PIN_DIAL) == GPIO.LOW:
            time.sleep(0.01)
 
        # Attendre que le cadran soit de nouveau pressé ou qu'une pause plus longue se produise
        impulse_time = time.time()
        while GPIO.input(GPIO_PIN_DIAL) == GPIO.HIGH:
            time.sleep(0.01)
            if time.time() - impulse_time > 0.2:  # Temps de pause entre les chiffres
                break
 
        # Comptabiliser une impulsion
        dial_count += 1
        impulse_time = time.time()
 
        # Vérifier s'il y a une pause plus longue, indiquant la fin de la séquence
        while GPIO.input(GPIO_PIN_DIAL) == GPIO.LOW:
            time.sleep(0.01)
            if time.time() - impulse_time > 0.2:  # Temps de pause entre les chiffres
                break
 
        if time.time() - impulse_time > 0.2:
            break
 
    if dial_count == 10:
        return 0
    return dial_count
 
def concatenate_digits(last_digit_time: float, new_digit: int, concatenated_digits: str) -> (float, str):
    """Concatène les chiffres s'ils sont saisis dans les 2.3 secondes."""
    current_time = time.time()
 
    if current_time - last_digit_time < 2.3:
        concatenated_digits += str(new_digit)
    else:
        if concatenated_digits:
            print(f"Numéro composé : {concatenated_digits}")
        concatenated_digits = str(new_digit)
 
    last_digit_time = current_time
    return last_digit_time, concatenated_digits
 
def find_sound_file(concatenated_digits: str) -> Optional[str]:
    """Recherche un fichier audio correspondant aux chiffres concaténés."""
    print(f"Recherche de fichier pour le numéro composé : {concatenated_digits}")
    for file in os.listdir(SOUND_DIR):
        if file.startswith(concatenated_digits + "_"):
            print(f"Fichier trouvé : {file}")
            return file
    print("Aucun fichier trouvé pour le numéro composé.")
    return None
 
def main() -> None:
    """Fonction principale pour gérer l'interaction téléphonique."""
    try:
        # Lecture du fichier notif.mp3 à l'initialisation
        play_sound(os.path.join(SOUND_DIR, "notif2.mp3"))
        time.sleep(5)  # Attendre 5 secondes pour que le son se termine
 
        while True:  # Boucle principale
            wait_for_off_hook()  # Attendre que le téléphone soit décroché
 
            dialed_number = ""
            concatenated_digits = ""
            composition_started = False
 
            last_digit_time = time.time()
 
            while GPIO.input(GPIO_PIN_OFF_HOOK) == GPIO.LOW:
                digit = read_dial()
                if digit is not None:
                    if not composition_started:
                        stop_sound()  # Arrête la tonalité une fois que la numérotation commence
                        composition_started = True
                    dialed_number += str(digit)
                    print(f"Numéro composé jusqu'à présent : {dialed_number}")
 
                    # Mettre à jour concatenated_digits avec le nouveau chiffre
                    last_digit_time, concatenated_digits = concatenate_digits(last_digit_time, digit, concatenated_digits)
 
            if concatenated_digits:
                search_file = find_sound_file(concatenated_digits)
                if search_file:
                    play_sound(os.path.join(SOUND_DIR, "recherche.mp3"))
                    play_sound(os.path.join(SOUND_DIR, search_file))
                else:
                    play_sound(os.path.join(SOUND_DIR, "non3.mp3"))
 
            stop_sound()  # Arrête le son si le téléphone est raccroché
 
    except KeyboardInterrupt:
        print("Programme interrompu par l'utilisateur.")
    finally:
        stop_sound()  # Assure l'arrêt du son en cours
        GPIO.cleanup()  # Nettoie les GPIO à la fin du programme
        print("Nettoyage des GPIO et arrêt du programme.")

Je commence tout juste en Python il doit y avoir une logique qui me manque.
J'ai essayer avec un LLM de trouver le soucis mais sans succès.



Merci pour votre aide.