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

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:

 

Le schéma électronique

Cliquez pour agrandir

Configuration du système

On modifie les noms des raspberry en « rasptalk-a », « rasptalk-b », « rasptalk-c » …

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

Aller dans le répertoire .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.

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:

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..)

On dé-commente les lignes suivantes:

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:

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

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

Puis retourner dans $HOME/.ssh

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

Enfin on redémarre ssh:

Un synthétiseur pour vocaliser les erreurs

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

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

Configuer le microphone

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

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:

Sinon on l’ajoute avec:

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

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:

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:

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:
http://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

          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 .

          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 )

    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
        http://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.