Compteur d’impulsions cadran téléphonique python

Version imprimable

Bonjour,

Je cherche à utiliser un vieux tel à cadran avec un raspbery pi pour déclencher des sons en fonction du numéro composé.
J’ai trouvé différents tutos, mais cela ne correspondait pas exactement à ce que je voulais.
Je suis donc parti de zéro, et je suis débutant en python…

J’ai fait ce petit programme afin que lorsque l’utilisateur actionne le cadran, le chiffre correspondant s’affiche :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) INPT = 17 GPIO.setup(INPT, GPIO.IN) COMPTEUR = 0 while True: while ( GPIO.input( INPT ) == False): COMPTEUR = 0 pass while ( GPIO.input( INPT ) == True): COMPTEUR += 1 time.sleep(0.17) print COMPTEUR GPIO.cleanup()
malheureusement le compteur ne s’incrémente pas, il ne me renvoie que des 1.
et je n’arrive pas à résoudre le problème… un peu d’aide serait bienvenue.
Merci

31/12/2018, 08h17
wiztricks

Salut,

Sans disposer de la même configuration matérielle et d'un oscilloscope, pas grand monde pourra vous aider.
Côté programmation, vous devez pouvoir vous inspirer de sources qui, à priori, fonctionnent. Ce qui suppose savoir lire ce genre de codes et arriver à décortiquer comment ils fonctionnent (signal de l'oscillo. en tête).
Ce qui vous donne une idée de tout ce qu'il faudrait maîtriser avant de pouvoir se lancer la dedans sans être perdu.

- W
31/12/2018, 11h40
jojomonk

Merci pour votre réponse,

effectivement, j'avais déjà vu ce code qui est un peu plus complexe que ce que je veux faire...
Pour ce qui est mon code, j'y suis presque, car lorsque je tourne le cadran, le code me renvoie le bon nombre de 1.
Le problème c'est qu'entre chaque 1 reçu, il doit y avoir un 0 qui remet le compteur à zéro...
Il faudrait que lorsque le programme reçoit un zéro, il déclenche un timer qui chronomètre le temps passé jusqu'au prochain 1, et si ce temps est trop long (genre 1/2s par ex), on en déduit que la numérotation est fini, on affiche le nb et on remet à zéro le compteur, et c'est cela que je ne sais pas faire...
31/12/2018, 12h03
wiztricks

Citation:

Envoyé par jojomonk

Il faudrait que lorsque le programme reçoit un zéro, il déclenche un timer qui chronomètre le temps passé jusqu'au prochain 1, et si ce temps est trop long (genre 1/2s par ex), on en déduit que la numérotation est fini, on affiche le nb et on remet à zéro le compteur, et c'est cela que je ne sais pas faire...

C'est exactement ce que fait le code que je vous ai indiqué.

- W

oui sauf que j'ai cette erreur, lorsque je lance ce code :

Code:

1
2
 
RuntimeError: Failed to add edge detection

Pour info j'ai modifié le code comme ci dessous :

Code:

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
 
# Rotary Dial Parser
# Expects the following hardware rules:
# 1 is 1 pulse
# 9 is 9 pulses
# 0 is 10 pulses
 
import RPi.GPIO as GPIO
from threading import Timer
import time
 
class RotaryDial:
 
    # We'll be reading BCM GPIO 4 (pin 7 on board)
    pin_rotary = 17
 
    # We'll be reading on/off hook events from BCM GPIO 3
    #pin_onhook = 3
 
    # After 900ms, we assume the rotation is done and we get
    # the final digit. 
    digit_timeout = 0.9
 
    # We keep a counter to count each pulse.
    current_digit = 0
 
    # Simple timer for handling the number callback
    number_timeout = None
 
    last_input = 0
 
    # Timer to ensure we're on hook
    #onhook_timer = None
    #should_verify_hook = True
 
    def __init__(self):
        # Set GPIO mode to Broadcom SOC numbering
        GPIO.setmode(GPIO.BCM)
 
        # Listen for rotary movements
        GPIO.setup(self.pin_rotary, GPIO.IN)
        GPIO.add_event_detect(self.pin_rotary, GPIO.BOTH, callback = self.NumberCounter)
 
        # Listen for on/off hooks
     #   GPIO.setup(self.pin_onhook, GPIO.IN)
      #  GPIO.add_event_detect(self.pin_onhook, GPIO.BOTH, callback = self.HookEvent, bouncetime=100)
 
       # self.onhook_timer = Timer(2, self.verifyHook)
        #self.onhook_timer.start()
 
    # Handle counting of rotary movements and respond with digit after timeout
    def NumberCounter(self, channel):
        input = GPIO.input(self.pin_rotary)
        #print "[INPUT] %s (%s)" % (input, channel)
        if input and not self.last_input:
            self.current_digit += 1
 
            if self.number_timeout is not None:
                self.number_timeout.cancel()
 
            self.number_timeout = Timer(self.digit_timeout, self.FoundNumber)
            self.number_timeout.start()
        self.last_input = input
   #     time.sleep(0.002)
 
    # Wrapper around the off/on hook event 
    #def HookEvent(self, channel):
     #   input = GPIO.input(self.pin_onhook)
      #  if input:
       #     self.hook_state = 1
        #    self.OffHookCallback()
        #else:
         #   self.hook_state = 0
          #  self.OnHookCallback()
 
    #def StopVerifyHook(self):
     #   self.should_verify_hook = False
 
    #def verifyHook(self):
     #   while self.should_verify_hook:
      #      state = GPIO.input(self.pin_onhook) 
       #     self.OnVerifyHook(state)
        #    time.sleep(1)
 
    # When the rotary movement has timed out, we callback with the final digit
    def FoundNumber(self):
        if self.current_digit == 10:
            self.current_digit = 0
        self.NumberCallback(self.current_digit)
        self.current_digit = 0
 
    # Handles the callbacks we're supplying
    def RegisterCallback(self, NumberCallback, OffHookCallback, OnHookCallback, OnVerifyHook):
        self.NumberCallback = NumberCallback
        #self.OffHookCallback = OffHookCallback
        #self.OnHookCallback = OnHookCallback
        #self.OnVerifyHook = OnVerifyHook
 
        input = GPIO.input(self.pin_onhook)
        #if input:
         #   self.OffHookCallback()
        #else:
#self.OnHookCallback()
 
while True:
    RotaryDial()
    GPIO.cleanup()

car je n'utilise pas l'interrupteur de décroché/raccroché du tel...

31/12/2018, 12h36
wiztricks
Citation:
Envoyé par jojomonk

oui sauf que j'ai cette erreur, lorsque je lance ce code :

Code:

1 2 RuntimeError: Failed to add edge detection
Un peu de recherche sur Internet vous indiquerait qu'il s'agit peut être d'un problème de PIN (là vous avez branché le truc) ou de version...

- W
31/12/2018, 14h59
jojomonk

ce que je ne comprends c'est que lorsque j'utilise la même instruction dans un autre code, je n'ai pas ce message d'erreur
31/12/2018, 18h24
jojomonk

Bon, j'ai réussi à faire fonctionner le code précédent.
D'après ce que je comprends, j'avais une erreur car le GPIO.add_event était dans une boucle while true.

Le problème que j'ai maintenant, c'est que le programme m'affiche des numéros, mais ils ne correspondent pas au numéros du cadran, et en plus je n'ai pas toujours le même numéro.
peut-être le cadran lui-même est-il défectueux ?

AAAAH ça marche, c'était juste une question de timing, maintenant j'ai les bons numéros...
Mais comment mettre ça dans une boucle ?

Code:

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
 
# Rotary Dial Parser
# Expects the following hardware rules:
# 1 is 1 pulse
# 9 is 9 pulses
# 0 is 10 pulses
 
import RPi.GPIO as GPIO
from threading import Timer
import time
 
class RotaryDial:
 
    # We'll be reading BCM GPIO 4 (pin 7 on board)
    pin_rotary = 4
 
    # We'll be reading on/off hook events from BCM GPIO 3
   # pin_onhook = 3
 
    # After 900ms, we assume the rotation is done and we get
    # the final digit. 
    digit_timeout = 0.5
 
    # We keep a counter to count each pulse.
    current_digit = 0
 
    # Simple timer for handling the number callback
    number_timeout = None
 
    last_input = 0
 
    # Timer to ensure we're on hook
   # onhook_timer = None
   # should_verify_hook = True
 
    def __init__(self):
        # Set GPIO mode to Broadcom SOC numbering
        GPIO.setmode(GPIO.BCM)
 
        # Listen for rotary movements
        GPIO.setup(self.pin_rotary, GPIO.IN)
        GPIO.add_event_detect(self.pin_rotary, GPIO.BOTH, callback = self.NumberCounter)
 
        # Listen for on/off hooks
       # GPIO.setup(self.pin_onhook, GPIO.IN)
       # GPIO.add_event_detect(self.pin_onhook, GPIO.BOTH, callback = self.HookEvent, bouncetime=100)
 
       # self.onhook_timer = Timer(2, self.verifyHook)
       # self.onhook_timer.start()
 
    # Handle counting of rotary movements and respond with digit after timeout
    def NumberCounter(self, channel):
        input = GPIO.input(self.pin_rotary)
        #print "[INPUT] %s (%s)" % (input, channel)
        if input and not self.last_input:
            self.current_digit += 1
 
            if self.number_timeout is not None:
                self.number_timeout.cancel()
 
            self.number_timeout = Timer(self.digit_timeout, self.FoundNumber)
            self.number_timeout.start()
        self.last_input = input
        time.sleep(0.02)
 
    # Wrapper around the off/on hook event 
   # def HookEvent(self, channel):
    #    input = GPIO.input(self.pin_onhook)
     #   if input:
      #      self.hook_state = 1
       #     self.OffHookCallback()
        #else:
         #   self.hook_state = 0
          #  self.OnHookCallback()
 
   # def StopVerifyHook(self):
    #    self.should_verify_hook = False
 
   # def verifyHook(self):
    #    while self.should_verify_hook:
     #       state = GPIO.input(self.pin_onhook) 
      #      self.OnVerifyHook(state)
       #     time.sleep(1)
 
    # When the rotary movement has timed out, we callback with the final digit
    def FoundNumber(self):
        if self.current_digit == 10:
            self.current_digit = 0
#        self.NumberCallback(self.current_digit)
        print(self.current_digit)
        self.current_digit = 0
 
    # Handles the callbacks we're supplying
#    def RegisterCallback(self, NumberCallback, OffHookCallback, OnHookCallback, OnVerifyHook):
#        self.NumberCallback = NumberCallback
       # self.OffHookCallback = OffHookCallback
       # self.OnHookCallback = OnHookCallback
       # self.OnVerifyHook = OnVerifyHook
 
       # input = GPIO.input(self.pin_onhook)
       # if input:
        #    self.OffHookCallback()
       # else:
#self.OnHookCallback()
try:
    RotaryDial()
    time.sleep(30)
finally:
    GPIO.cleanup()

Salut,

Citation:

Envoyé par jojomonk

Mais comment mettre ça dans une boucle ?

Tel que le code est écrit, vous ne pouvez pas le mettre dans une boucle mais juste déclarer un callback qui sera appelé pour chaque numéro décodé.
C'est là que çà se passe:
Code:

1 2 3 4 5 6 7 # When the rotary movement has timed out, we callback with the final digit def FoundNumber(self): if self.current_digit == 10: self.current_digit = 0 # self.NumberCallback(self.current_digit) print(self.current_digit) self.current_digit = 0
- W

01/01/2019, 19h53
jojomonk

Je ne comprends pas trop comment fonctionnent les callbacks, ni comment faire pour les créer??

Pour l'instant ce que j'arrive à faire c'est de lancer le RotaryDial(), si je rajoute un délai d'attente, je peux numéroter plusieurs chiffres jusqu'à la fin du time.sleep, mais je n'arrive pas à relancer le RotaryDial indéfiniment...

En tout cas merci pour votre aide, et Bonne Année :)
02/01/2019, 09h41
wiztricks

Salut,

Citation:

Envoyé par jojomonk

Je ne comprends pas trop comment fonctionnent les callbacks, ni comment faire pour les créer??

Ce style de programmation dit "piloté par les évènements" est abordé dans la plupart des tuto. à travers la programmation d'une interface graphique (généralement avec tkinter).

Si vous voulez écrire un code "séquentiel", il ne faut pas utiliser de callback déjà dans GPIO.add_event_detect et bloquer sur des appels à GPIO.event_detected.
Un peu de recherche sur Internet vous indiquerait des tutos. où sont comparées les deux méthodes.

Citation:

Envoyé par jojomonk

En tout cas merci pour votre aide, et Bonne Année :)

Meilleurs voeux à vous aussi.

- W

Bon, j'ai pas mal avancé, mais j'ai toujours un problème:
J'ai créer un module qui lit des mp3, j'ai repris qvec quelques modifs, le RotaryDial et le TelephonDaemon du lien (voir + haut).
Mon problème c'est que les numéros qui sont composés s'ajoutent (c'est à dire, si je compose 1 puis 3, ça me donne 4, etc...), or ce que je voudrais c'est uniquement des numéros de 1 à 10.
Je ne sais pas, non plus comment bloquer le programme le temps de la lecture du son (c'est à dire qu'il ne soit pas possible de lancer un mp3 avant que le précédent ne soit fini...

Voici les codes :

le telephondaemon :

Code:

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
 
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#lecteur de mp3 piloté par tel à cadran socotel s63
import os
import Queue
import threading
import signal
import sys
#import yaml
import RPi.GPIO as GPIO
import time
from s63.RotaryDial import RotaryDial
from s63.Sons import Sons
 
callback_queue = Queue.Queue()
 
class TelephonDaemon:
 
    last = 0
    dial_number = 0
    RotaryDial = None
    #Sons = None
    def __init__(self):
        print("[STARTUP]")
        self.RotaryDial = RotaryDial()
        self.RotaryDial.RegisterCallback(NumberCallback = self.GotDigit)
        #self.Sons()
        raw_input("Waiting.\n")
 
    def GotDigit(self, digit):
        print "[DIGIT] Got digit: %s" % digit
        self.dial_number = digit
        self.dial_number = digit - self.last 
        print "[NUMBER] We have: %s" % self.dial_number
        #if len(self.dial_number) == 2:
        Sons(self.dial_number)
        self.dial_number = self.last
        self.dial_number = 0
 
def main():
    TDaemon = TelephonDaemon()

le RotaryDial :

Code:

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
 
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Rotary Dial Parser
# Expects the following hardware rules:
# 1 is 1 pulse
# 9 is 9 pulses
# 0 is 10 pulses
 
import RPi.GPIO as GPIO
from threading import Timer
import time
 
class RotaryDial:
   # global current_digit
    # We'll be reading BCM GPIO 4 (pin 7 on board)
    pin_rotary = 4
 
 
    # After 900ms, we assume the rotation is done and we get
    # the final digit. 
    digit_timeout = 0.9
 
    # We keep a counter to count each pulse.
    current_digit = 0
 
    # Simple timer for handling the number callback
    number_timeout = None
 
    last_input = 0
    choix = 0
 
 
 
 
    def __init__(self):
        #global choix
        #global z
        #global current_digit
        current_digit = 0
        # Set GPIO mode to Broadcom SOC numbering
        GPIO.setmode(GPIO.BCM)
 
        # Listen for rotary movements
        GPIO.setup(self.pin_rotary, GPIO.IN)
        GPIO.add_event_detect(self.pin_rotary, GPIO.BOTH, callback = self.NumberCounter)
 
 
    # Handle counting of rotary movements and respond with digit after timeout
    def NumberCounter(self, channel):
        input = GPIO.input(self.pin_rotary)
        #print "[INPUT] %s (%s)" % (input, channel)
        if input and not self.last_input:
            self.current_digit += 1
 
            if self.number_timeout is not None:
                self.number_timeout.cancel()
 
            self.number_timeout = Timer(self.digit_timeout, self.FoundNumber)
            self.number_timeout.start()
        self.last_input = input
        time.sleep(0.02)
 
# When the rotary movement has timed out, we callback with the final digit
    def FoundNumber(self):
        #if self.current_digit == 10:
           # self.current_digit = 0
        self.NumberCallback(self.current_digit)
        print("current_digit:", self.current_digit)
        return self.current_digit
#       self.choix = self.current_digit
        #return z
        self.current_digit = 0
 # Handles the callbacks we're supplying
    def RegisterCallback(self, NumberCallback):
        self.NumberCallback = NumberCallback

et le lecteur mp3 :

Code:

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
 
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import random
import pygame
 
SONG_END = 0
 
class Sons(object):
    """ lecteur de fichiers mp3"""
    """ les fichiers doivent être renommés : x.mp3 ou x entre 0 et 9"""
    last = 0
    def __init__(self, num =0):
 
        global fin
        SONG_END = 0
        fin = 0
        self.digit = num
        self.digit = num - self.last
#emplacement du dossier de sons
        if self.digit != 0:
            chemin = "/home/pi/sons/xx.mp3"
            chemin = chemin.replace("xx", str(self.digit))
            pygame.mixer.init(48000, -16, 2, 4096)
        #pygame.mixer.music.set_endevent(SONG_END)
            pygame.mixer.music.load(chemin)
            pygame.mixer.music.play()     
        #SONG_END = pygame.mixer.music.get_busy()
            while pygame.mixer.music.get_busy():
                pass
            print("fin")
            fin = 1
        else:
            print("pas de sons")
        self.digit = self.last
        print("num", self.digit)

04/01/2019, 19h14
wiztricks

Salut,

Dans rotarydial, le "return..." de la ligne 70 fait que l'instruction suivante self.current_digit = 0 n'est pas exécutée.

Je ne vois pas ce que vient faire la lecture mp3 ici: ouvrez un autre sujet.

- W
04/01/2019, 19h33
jojomonk

Merci,

ça marche!

pour la lecture mp3, ça fait partie du même projet, mais vous avez raison, on s'éloigne du sujet...