Publié le 20 septembre 2017 - par

Interphone wifi multi-postes avec un Raspberry Pi

Je vous propose de découvrir un objet qui amuse beaucoup les enfants, mais qu’on peut aussi adapter comme interphone de porte.

Bonjour à tous, je m’appelle Pascal, bidouilleur du dimanche, c’est la première fois que j’ai l’occasion de poster un article ici.

Cliquez pour avoir des infos sur les niveaux

Interphone wifi multi-postes avec un Raspberry Pi

J’ai beaucoup cherché une façon pour streamer de l’audio par le wifi, et finalement j’ai réalisé mon projet de la façon qui me semble la plus simple: en utilisant une connexion SSH et les commandes arecord/aplay du pilote ALSA de la sortie sonore de notre Raspberry Pi. Le principe est simple, on presse le bouton quand on parle, et notre interlocuteur nous entend 🙂 Dans ma version j’utilise un bouton rotatif avec plusieurs interphones, mais on peut évidement n’en utiliser que deux et ainsi ne mettre qu’un seul bouton. Sinon j’utilise un micophone USB, un Haut-parleur amplifié, et un fichier Python.

Liste du matériel (pour un interphone)

1 Raspberry Pi
1 Micro SD Card
1 adaptateur secteur (j’ai utilisé un 5v 6A pour alimenter aussi l’ampli)
1 Microphone USB
1 Haut-parleur 8 Ohms 10W (en fonction de l’ampli)
1 ampli pour le HP (moi j’ai utilisé celui d’Adafruit 20W MAX9744)
1 câble avec 2 prises Jack
1 Led rouge 10mm (témoin d’émission)
2 Boutons poussoir au minimum (un pour parler et un pour éteindre le Raspberry)
1 résistance de 100 Ohms
1 résistance de 10 KOhms
1 platine en bakélite

si plusieurs interphones:
1 encodeur rotatif de sélection
plusieurs Leds (le même nombre qu’il y a de postes)
2 Boutons poussoir (pour déclencher un buzzer, et le mode “absent”)
1 buzzer et son transistor NPN
X résistances de 100 Ohms et 10 KOhms (le même nombre qu’il y a de postes)

Le code python

#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
Ce script fonctionne avec 2 interphones, par souci de clarté du code je n'ai pas mis la partie de gestion de plusieurs interphones avec
le bouton encodeur rotatif ni le bouton qui rend ce poste "absent". Pour + d'info sur l'encodeur rotatif voir le tuto dans les sources.

Fonctionnement:
Lorsqu'on appuie sur le bouton "Parler" on génère un flux audio en ssh qu'on lit sur le terminal destinataire.
Le fait de relâcher ce bouton, termine le flux.

Quand on appuie sur le bouton "Buzzer" pour faire sonner l'interphone qu'on appelle: en fait on crée un fichier appelé "sonne" sur le poste
distant. Celui-ci check la présence de ce fichier en boucle, quand il existe il fait sonner son buzzer avant de supprimer le fichier "sonne"

Pour terminer, j'utilise le synthétiseur vocal pico2wave pour générer un son lors d'erreurs (Surtout utilisé si on tente de communiquer
avec un interphone qui a enclenché son bouton "Absent" cela génère une phrase comme quoi il est impossible de le contacter..)
'''
import RPi.GPIO as gpio
import time
import os

# Configuration des variables
ce_terminal = 'a' # ce script est sur le terminal rasptalk-a
destinataire = 'j' # ce script envoie sur -j (sera modifiable avec le bouton rotatif)
etat_absent = 0 # etat du bouton absent (1 si bouton enfoncé)
etat_parler = 0 # etat du bouton parler (rec)
etat_buzzer = 0
print("- - - Ce terminal est: " + ce_terminal + " et notre destinataire: " + destinataire + " - - -")

# on definit les numero des gpio
# Les Entrées (les boutons)
bouton_absent = 18
bouton_parler = 23
bouton_buzzer = 24
bouton_shutdown = 25
bouton_select1 = 16
bouton_select2 = 21
# Les Sorties (les leds)
le_buzzer = 22
led_absent = 17
led_parle = 27
led_rec = 5
led_posteA = 6
led_posteB = 13
led_posteC = 19
led_posteD = 26

gpio.setmode(gpio.BCM) # on utilise les Gpio en mode BCM
gpio.setup(bouton_absent, gpio.IN) # on défini ces ports comme entrées pour lire les positions des boutons
gpio.setup(bouton_parler, gpio.IN)
gpio.setup(bouton_buzzer, gpio.IN)
gpio.setup(bouton_shutdown, gpio.IN)
gpio.setup(bouton_select1, gpio.IN)
gpio.setup(bouton_select2, gpio.IN)

gpio.setup(led_absent, gpio.OUT) # et ceux-ci comme sorties pour allumer/éteindre les led
gpio.setup(le_buzzer, gpio.OUT)
gpio.setup(led_parle, gpio.OUT)
gpio.setup(led_rec, gpio.OUT)
gpio.setup(led_posteA, gpio.OUT)
gpio.setup(led_posteB, gpio.OUT)
gpio.setup(led_posteC, gpio.OUT)
gpio.setup(led_posteD, gpio.OUT)

# On génère un son de bienvenue avec le synthétiseur vocal pico2wave
os.system('pico2wave -l fr-FR -w 0.wav "Bienvenue sur ce terminal. il est prêt a fonctionner." && aplay 0.wav && rm 0.wav')


while True: # boucle infinie
    # Gestion bouton parler
    if(gpio.input(bouton_parler) == True): # si le "bouton parler" est pressé: (Parfois mettre False au lieu de True si notre bouton est off (on) ou on (off) c'est à dire qu'il coupe quand on appuie..
        if etat_absent == 0: # etat du bouton absent (ici le terminal n'est pas sur absent)
            gpio.output(led_rec, gpio.HIGH) # on allume la led rec
            if etat_parler == 0: # si le bouton rec n'a pas déjà été pressé -> on envoie un flux audio par ssh
                etat_parler = 1 # on met la variable à 1
                print("Le terminal desinataire n'est pas absent -> envoi du flux audio")
                os.system('sudo ./record-' + destinataire + '.py &') # on execute record-j.py en arrière plan, et on kill son processus quand on relâche le bouton "parler"
            else: # le bouton rec a déjà été pressé dans une autre boucle -> on ne fait rien
                print ("le bouton rec a déjà été pressé on ne fait rien car le flux audio est déjà en cours")
        else: # si etat du bouton absent = 1
            # On génère un son d'erreur pour prévenir que personne ne peut nous contacter
            os.system('pico2wave -l fr-FR -w 0.wav "Votre bouton, absent, est effoncé, il est impossible de communiquer." && aplay 0.wav && rm 0.wav')
    else: # si le "bouton parler" n'est pas pressé
        if etat_parler == 1: # le bouton rec n'était pas encore relâché -> on arrête l'enregistrement en tuant son processus
            etat_parler = 0 # on remet la variable à 0
            gpio.output(led_rec, gpio.LOW) # on éteint la led rec
            print ("Le bouton rec vient d'être relâché -> on tue les processus ayant comme nom: arecord")
            os.system('killall arecord')


    # Gestion bouton absent
    if(gpio.input(bouton_absent) == True): # si le "bouton absent" est pressé:
        if etat_parler == 0: # on check qu'on ne soie pas en train de parler (si c'est le cas on ne fait rien)
            if etat_absent == 0: # si on ne parle pas et on est pas deja absent
                print("Le bouton absent est enfoncé et on est pas en mode absent: etat_absent -> 1")
                etat_absent = 1 # on bascule l'état absent à 1
                # on envoie le fichier "absent-ce_terminal" sur tous les destinataires
                os.system('ssh pi@rasptalk-' + destinataire + ' "touch /home/pi/rasptalk/absent-' + ce_terminal + '"')
                gpio.output(led_absent, gpio.HIGH) # on allume la led absent
                time.sleep(0.8)
            else: # si on ne parle pas mais on est deja absent
                print("Le bouton absent est enfoncé mais on est deja en mode absent: etat_absent -> 0")
                etat_absent = 0 # on bascule l'état absent à 0
                os.system('ssh pi@rasptalk-' + destinataire + ' "rm /home/pi/rasptalk/absent-' + ce_terminal + '"')
                gpio.output(led_absent, gpio.LOW) # on éteint la led absent
                time.sleep(0.8)
        if etat_parler == 1: # on a enfoncé le bouton "absent" alors qu'on est déjà en train de parler
            print("On ne tient pas compte de l'enfoncement du bouton absent car le bouton parle est aussi pressé")


    # Gestion bouton buzzer
    if(gpio.input(bouton_buzzer) == False): # si le "bouton buzzer" est pressé:
        if etat_absent == 1: # si on est absent
            # On génère un son d'erreur pour prévenir que personne ne peut nous contacter
            os.system('pico2wave -l fr-FR -w 0.wav "Votre bouton, absent, est effoncé, il est impossible de communiquer." && aplay 0.wav && rm 0.wav')
        else: # si "bouton buzzer" est pressé et si on est pas "absent"
            # On génère un son avec le buzzer du correspondant en créant le fichier "sonne"
            os.system('ssh pi@rasptalk-' + destinataire + ' "touch /home/pi/rasptalk/sonne"')
            print("Le fichier sonne a été créé sur pi@rasptalk-" + destinataire + " pour faire sonner son buzzer")
            time.sleep(0.8)


    # Gestion bouton shutdown
    if(gpio.input(bouton_shutdown) == False): # si le "bouton shutdown" est pressé:
            print("Bouton shutdown -> au revoir!")
            # On génère un son de fin de programme
            os.system('pico2wave -l fr-FR -w 0.wav "Le système va séteindre. Attendez au moins 2 minute avant de retirer la prise." && aplay 0.wav && rm 0.wav')
            for i in range(0,4): # on fait cligoter 4x toutes les leds
                gpio.output(led_absent, gpio.LOW)
                gpio.output(led_parle, gpio.LOW)
                gpio.output(led_rec, gpio.LOW)
                gpio.output(led_posteA, gpio.LOW)
                gpio.output(led_posteB, gpio.LOW)
                gpio.output(led_posteC, gpio.LOW)
                time.sleep(0.4)
                gpio.output(led_absent, gpio.HIGH)
                gpio.output(led_parle, gpio.HIGH)
                gpio.output(led_rec, gpio.HIGH)
                gpio.output(led_posteA, gpio.HIGH)
                gpio.output(led_posteB, gpio.HIGH)
                gpio.output(led_posteC, gpio.HIGH)
                time.sleep(0.4)
            os.system('sudo shutdown -h now') # on éteint le système


    # Gestion fichier "sonne"
    if os.path.isfile("/home/pi/rasptalk/sonne"): # On check si on a reçu un fichier "sonne"
        print("Oh il y a un fichier 'sonne' -> on déclenche le buzzer")
        os.system('rm /home/pi/rasptalk/sonne') # on efface le fichier "sonne"
        gpio.output(le_buzzer, gpio.HIGH) # on allume le buzzer
        time.sleep(0.7)
        gpio.output(le_buzzer, gpio.LOW) # on l'éteint


    time.sleep(0.3)  # pour diminuer la charge CPU

Quand on enfonce le bouton “Parler” le programme ci-dessus lance le script ci-dessous, de cette façon la boucle infinie peut continuer et attendre le moment où l’on relâche le bouton et ainsi tuer le processus de ce 2ème script:

#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
Quand on enfonce le bouton "parler" le programme principal lance ce script en arrière plan avec la commande:
os.system('sudo ./record-a.py &')

De cette façon, la boucle infinie du programme principal peut continuer et checker le moment où l'on relâche le bouton "parler" et à ce moment on tuera son processus avec la commande:
os.system('killall arecord')
'''
import os
os.system('if [ -f "/home/pi/rasptalk/absent-a" ]; then pico2wave -l fr-FR -w 0.wav "Le bouton, absent, est effoncé chez votre correspondant. Il est impossible de lui parler."; aplay 0.wav; rm 0.wav; else arecord -D plughw:1 -f dat | ssh -C pi@rasptalk-a aplay -f dat; fi')

 

Le schéma électronique

Cliquez pour agrandir

Configuration du système

On modifie les noms des raspberry en “rasptalk-a”, “rasptalk-b”, “rasptalk-c” …

sudo nano /etc/hostname -> modifier le nom 
puis dans sudo nano /etc/hosts -> idem tout en bas

Mise en place d’un certificat SSH

Pour pouvoir utiliser une connexion ssh sans avoir à entrer un mot de passe, nous allons créer un certificat sous forme de clef privée, clef publique.
S’il n’existe pas, créer le répertoire .ssh

 mkdir $HOME/.ssh
 sudo chmod 700 $HOME/.ssh

Aller dans le répertoire .ssh

 cd $HOME/.ssh

Nous allons générer nos clés, -b 4096 permet d’augmenter la sécurité de votre clé au lieu de 2096 par défaut, le -C “commentaire” servira à repérer la clef publique parmi d’autres dans le fichier ~/.ssh/authorized_keys que nous créerons plus tard sur le serveur.

 ssh-keygen -b 4096 -C "pi@rasptalk-a"

La commande nous demande d’indiquer le nom du fichier dans lequel sauver les clefs:
On fait juste [ENTER] de sorte que la clef soie générée et placée dans le dossier .ssh/id_rsa
Puis on laisse la passphrase vide afin qu’il ne la demande pas
Nous voilà avec une clé privée (id_rsa) et une clé publique (id_rsa.pub)

La clé privée doit être gardée dans le répertoire .ssh et la publique est celle à mettre sur le serveur qui veut se connecter.

Il faut maintenant ajouter de la clé publique au fichier authorized_keys situé dans le dossier /home/user/.ssh du serveur:

 cat id_rsa.pub | ssh <nom_utilisateur>@<adresse_ip> 'cat >> ~/.ssh/authorized_keys'

La ligne est ajoutée au fichier ~/.ssh/authorized_keys du serveur sous la forme: ssh-rsa <clé-cryptée> commentaire

On va finir avec la modification de la configuration du service SSH: (donc en local pas sur le serveur..)

 sudo nano /etc/ssh/sshd_config

On dé-commente les lignes suivantes:

PubkeyAuthentication yes
RSAAuthentication yes
AuthorizedKeysFile %h/.ssh/authorized_keys

Maintenant une dernière chose, si on veut qu’un script exécuté par root puisse aussi utiliser la connexion ssh sans mot de passe:
On définit un mot de passe à l’administrateur du raspberry:

 sudo passwd root

puis on se connecte en tant que root avec la commande:

 su

Vérifiez que le dossier /root/.ssh existe (s’il n’existe pas: mkdir /root/.ssh)
Donnez-lui ces droits:

 chmod 700 /root/.ssh

Puis retourner dans $HOME/.ssh

 cd $HOME/.ssh

Envoyer les fichiers authorized_keys et id_rsa dans /root/.ssh

 cp authorized_keys /root/.ssh
 cp id_rsa /root/.ssh

Enfin on redémarre ssh:

 sudo service ssh restart

Un synthétiseur pour vocaliser les erreurs

Installation d’un synthétiseur vocal qui lit les erreurs, par exemple si le correspondant est éteint:

 sudo apt-get install libttspico-utils

test de création du fichier .wav et lecture du fichier:

pico2wave -l fr-FR -w fichier.wav "Bienvenue en cette belle journée!"
aplay fichier.wav

Configuer le microphone

vérifier que le micro soit vu sur le port USB:

 lsusb

qui donne genre: Bus 001 Device 008: ID 0d8c:0139 C-Media Electronics, Inc.

On peut vérifier que l’utilisateur pi soit bien dans le groupe audio:

 groups pi

Sinon on l’ajoute avec:

 sudo usermod -a -G audio pi

On va configurer le port du microphone et la carte audio:

 alsamixer

qui donne un shéma de réglage, utiliser F6 pour sélectionner la carte son:
bcm2835 est le raspberry (pour la sortie jack & hdmi)
et pour l’entrée mic: USB PnP sound device avec comme numéro de la carte: 1
Maintenant sur le shéma on peut monter le son du HP et du mic au moins à 50%
Tout à droite on a le ctrl automatique du gain en pressant la touche M (moi je le laisse auto)
Enfin enregistrer ces paramètres:

 sudo alsactl store 1

1 est le numéro de votre carte.
Pour tester l’enregistrement: un son de 4 secondes en 8 bit (venant du périphérique 1: -D plughw: 1) et on le lit avec aplay:

 arecord -D plughw:1 -d 4 test.wav
 aplay test.wav

Voilà, une dernière petite chose à faire attention:
si vous utilisez comme moi un jack pour le son, on met la sortie audio du raspberry en analogique et non sur HDMI (bouton droit sur l’HP à coté de l’horloge)

Booter directement sur un disque dur

Moi personnellement j’ai utilisé un pidrive, mais il est possible d’utiliser un vieux disque dur ou même une clé USB, voici un bon tuto:
https://www.framboise314.fr/boot-simplifie-sur-usb-avec-les-raspberry-pi-1-2-et-3/

Conclusions

J’ai eu un immense plaisir à vous présenter ma réalisation sur le blog de la framboise314 et j’en profite pour remercier François pour son accueil en ces pages!

C’est fou comme une idée simple n’est jamais simple à mettre en oeuvre, mais qu’on fasse n’importe quel projet on apprend à chaque fois plein de choses 🙂

Sources

Share Button

À propos Pascal Adatte

Bonjour, je m'appelle Pascal, j'ai 39 ans et je vis à Genève en Suisse.

21 réflexions au sujet de « Interphone wifi multi-postes avec un Raspberry Pi »

  1. MSG

    Bonjour Pascal ,

    Très beau projet , excellent .

    Je me permet de te donner deux petites astuces pour ton code :

    1°) En python , lorsque les lignes de code sont trop longues (> 80 caractères) , tu peux utiliser
    le code suivant qui te coupe la ligne tout en restant sur la même ligne de code .
    Il s’agit du code “+\”
    Exemple :
    if première_condition and +\
    seconde_condition and +\
    troisieme_condition :
    print ” hello”

    Ça fonctionne avec les liste , chaines de texte etc … et ça évite de scroller l’écran de gauche à droite pour lire comme ici sur la publication de ton code .

    2°) la détection d’état d’un bouton ne se limite pas à On (1) ou Off (0) , on peut étendre
    la détection au front montant et front descendant en utilisant une variable avec mise en forme .
    exemple :
    Bouton = ((Bouton << 1) | lecture_bit_adresse_GPIO ) &0b11
    ou
    Bouton = ((Bouton * 2) + lecture_bit_adresse_GPIO) % 4
    ou
    Bouton = ((Bouton << 1) + lectrure_bit_adresse_GPIO) % 4

    Cette commande décale les bits mémorisés d'un rang vers la gauche , puis le bit lu sur l'entrée
    GPIO est inséré par la droite et enfin le résultat est forcé à resté dans l'intervale de valeur 0 à 3 .
    0 = 0b00 = pas de pression sur le bouton
    1 = 0b01 = pression sur le bouton = front montant
    3 = 0b11 = bouton maintenu actionné
    2 = 0b10 = relachement du bouton = front descendant

    Il suffit de venir lire le bouton à intervale régulier suivit d'une pause , par exemple toutes les 10ms , ce qui fait une fréquence de lecture de 100 hz (100 fois par secondes c'est largement suffisant ) et évite d'avoir le CPU à fond sur la lecture du / des bouton(s) .
    Ça élimine aussi tout naturellement de possibles rebonds lors de la lecture .

    Répondre
    1. Pascal Adatte Auteur de l’article

      Bonjour,
      Merci beaucoup pour ton commentaire, génial le +\ je ne connaissais pas du tout!
      Par contre dans ta gestion des boutons c’est excellent d’utiliser une variable pour différencier les fronts montants des descendants, mais je ne comprends pas pourquoi ça déchargerait le CPU, car on fait quand même une boucle infinie, donc le problème est le même non?
      Mais je vais m’y intéresser et chercher un peu, merci bcp 🙂

      Répondre
      1. msg

        Bonjour ,

        Mettre une boucle sans fin pour questionner l’état d’un bouton , ça revient à faire un Paris-Marseille en voiture et demander toutes les minutes au chauffeur “on est arrivé ?”
        C’est exactement ce que ressent le CPU , tu le gonfle et il se met inutilement à chauffer !

        Dans de nombreux languages , tu as la commande PAUSE qui te permet de ralentir l’exécution du programme , en mettant le CPU en sommeil un certain temps .

        En python , cette commande n’existe pas ou s’appelle autrement .
        Je pense avoir trouver son équivalent dans la bibliothèque TIME .
        Elle s’appelle SLEEP (sommeil) et exécute des temps de sommeil en secondes .
        Faire : from time import sleep
        SLEEP accepte les nombres décimaux , il sera possible de lui indiquer des temps de sommeil très courts de l’ordre de quelques dixièmes ou centièmes de secondes .

        Comme le temps de réaction humain ne descend pas en dessous de 1/100 secondes (10ms) , on peut utiliser ce temps comme référence pour faire reposer le CPU si aucune action n’est détectée .

        Répondre
          1. msg

            Bonjour ,
            Désolé pour la commande SLEEP , j’ai eu une idée , puis j’ai été dérangé et je n’ai pas lu ton code jusqu’à la fin .

            Je reviens pour te donner une autre astuce afin de simplifier ton code .
            On va créer des mini fonctions afin d’écrire et lire dans une variable les informations importantes pour ton bouton .

            # fonction écriture
            bouton = lambda var , bit : +\
            (((var & 0b010) + bit) * 2) +\ # traitement des fronts
            + (marche(var) ^ appuis (var)) # traitement du marche- arret

            # fonctions lecture
            marche = lambda var : (var % 2) is 1
            appuis = lambda var : (var / 2) is 1

            # utilisation
            parler = 0 # toujour initialiser ses variables
            parler = bouton (parler , bit_du_GPIO) # écriture des données

            if marche(parler ) : # traitement direct sur le retour de la fonction
            parlez

            if appuis (parler) : # les fonctions retournent des booléan (True / False)
            pression sur le bouton (front montant)

            Bonne bidouille

            Répondre
          2. msg

            Je viens de me rendre compte que la fonction “bouton” est légèrement décalé dans le temps d’un cycle .

            On peut l’écrire comme suit pour que ça soit bien synchro :

            def bouton (var , bit) :
            up = 0b01
            dn = 0b10
            front = (var & 0b010) + bit
            m_a = (var & 0b001) ^ (front is up)
            etat = front * 2 + m_a
            return etat

            on l’appelle de la même façon :
            parler = bouton (parler , bit_GPIO)

            Le bit0 “m_a” de la variable “parler” change d’état à chaque front montant .

            Répondre
          3. msg

            Pense à indenter le code contenu dans la fonction Bouton .
            La publication de réponses du site efface les espaces à gauche du texte .

            Les fonctions “def” ou “lambda” se déclarent généralement en tête de programme , jamais à la fin .
            (du moins c’est comme celà que j’ai appris )

            Répondre
    1. Pascal Adatte Auteur de l’article

      Merci pour ton commentaire, c’est ma femme qui dit bidouilleurs du dimanche car nos montages ne servent souvent pas à grand chose 😀

      Répondre
  2. CDBI30

    suite aux remarques très justes de MSG, une autre:
    pour les entrées, on peut forcer le pull-up du GPIO
    GPIO.setup(bouton_absent, GPIO.IN,pull_up_down=GPIO.PUD_UP)
    Je ne mets plus de résistance au +3.3v

    Répondre
    1. Pascal Adatte Auteur de l’article

      J’avais lu qu’il est préférable pour la carte de ne pas les activer et utiliser des résistances, mais si tu es sûr de toi c’est vrai que ça fait un sacré travail de soudure en moins.
      C’est valable aussi pour les leds sur les sorties?

      Répondre
      1. CDBI30

        Pour les entrées:
        je met une résistance de limitation de courant de 1K en série avec le bouton
        qui lui met à la masse.
        J’ai 2 montages qui fonctionnent avec cela sans problème depuis un bon moment
        Pour les sorties:
        16mA max sur le GPIO, donc une résistance de 1K en série limite à 3 mA et c’a suffit pour une LED
        Mais si on a plusieurs LED sur le GPIO, il vaut mieux utiliser un ULN2803 pour les commander (500mA par sortie) et il protége le GPIO du Raspi.
        Regarde mon Boitier-PI3
        https://www.framboise314.fr/utilisation-simultanee-de-piface-2-sensehat-raspberry-pi-episode-iii/

        Répondre
  3. Jojo

    Bonjour Pascal,

    Merci beaucoup pour ce tuto, je n’arrivais pas à me défaire du Go: dans le code de TalkiePi, le Python ce sera beaucoup plus simple ! Et bravo pour l’intégration, tes enfants doivent adorer.

    Une question : je ne trouve pas dans les sources la partie sur le bouton encodeur rotatif dont tu parles et qui m’intéresse, c’est un oubli ou juste moi qui ne sait pas chercher ?

    Cordialement,
    Johan

    Répondre
    1. msg

      Bonjour ,
      Pour ceux qui sont fauchés , comme moi , on peut se fabriquer un encodeur modulable a souhait pour pas grand chose .
      Il faut juste 2 boutons poussoirs et c’est tout , le RPi fait le reste .

      Pour les fronts des boutons poussoir , on passe par une fonction “lambda” épurée (sans bit de bascule) :
      # la fonction retourne la valeur 0=bas ,1=monte, 2=descend, 3=haut
      front = lambda var , bit_gpio ; ((var % 2) <<1) + bit_gpio

      # Usage :
      bp1 = front (bp1 , gpio23)
      bp2 = front (bp2 , gpio24)
      t1 = front (t1 , int ( ( time() *4) %2) )

      Pour l'encodeur , on passe par une fonction 'def' car c'est un peu plus long :
      # la fonction retourne des valeurs comprises entre 0 et (maxi-1)
      def select ( cpt , maxi , a , b ) :
      __ if a == 1 : cpt += 1 # quand a monte , le compteur augmente
      __ if b == 1 : cpt -= 1 # quand b monte , le compteur décroit
      __ if a == 3 and t1 == 1 : # comptage auto sur front montant bit horloge
      _____ cpt += 1
      __ if b == 3 and t1 == 1 : # decomptage auto sur front montant bit horloge
      _____ cpt -= 1
      __ if a == 3 and b == 3 : # si a et b à l'état haut ,RAZ du compteur
      _____ cpt = 0
      __ cpt %= maxi # empêche cpt de sortir des limites 0 à (maxi-1)
      __ return cpt # retourne la nouvelle valeur

      # Usage : pour un sélecteur 10 positions (0 à 9)
      choix = select ( choix , 10 , bp1 , bp2)

      La bascule qui n'est pas intégrée dans la variable des boutons peut se faire autrement .
      ex :
      led1 ^= bp1 is 1 # la led change d'état à chaque front montant
      led2 ^= bp2 is 2 # la led change d'état à chaque front descendant

      Répondre
  4. xhark

    Super idée, beau billet !Pour la partie échanges des clés SSH tu peux simplifier avec ssh-copy-id :ssh-copy-id -i ~/.ssh/id_dsa.pub utilisateur@machine-distante

    Pour éviter la saturation du CPU il faudrait se tourner vers incron ou inotify qui permettent de vérifier la présence de fichier au niveau kernel. Sinon je crois que François Mocq a déjà fait un billet avec un thread en C.

    Répondre
    1. Pascal Adatte Auteur de l’article

      Salut,
      Je n’ai pas testé mais j’ai cherché sur le net et ça a l’air un peu + rapide à faire comme ça en effet, merci pour ton commentaire!
      Sinon pour le CPU il ne sature pas, au bout de 30 secondes de discussion apparaît un léger décalage, mais il suffit de relâcher le bouton. Et comme je pense qu’en moyenne on fait 10 ou 20 sec par message, y a aucun souci 🙂

      Répondre
  5. Damien

    Bonjour, joli tuto 🙂
    Je voudrais savoir si il existe un tuto similaire pour bricoler une solution d’interphones (évetuellement avec la vidéo), pouvant resposer sur le protocole SIP…

    Répondre
    1. Pascal Adatte Auteur de l’article

      Salut Damien,
      Moi j’utiliserais Motion avec soit un serveur apache pour afficher la vidéo dans un navigateur internet, soit PyGame afin d’afficher les images dans un programme python.
      Par contre il ne sera pas du tout compatible SIP, protocole que je ne connais pas du tout..
      Si d’autres ont des idées..

      Répondre

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Complétez ce captcha SVP * Time limit is exhausted. Please reload CAPTCHA.

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.