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
Au sommaire :
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
|
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 |
#!/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:
|
1 2 3 4 5 6 7 8 9 10 11 |
#!/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 » …
|
1 2 |
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
|
1 2 |
mkdir $HOME/.ssh sudo chmod 700 $HOME/.ssh |
Aller dans le répertoire .ssh
|
1 |
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.
|
1 |
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:
|
1 |
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..)
|
1 |
sudo nano /etc/ssh/sshd_config |
On dé-commente les lignes suivantes:
|
1 2 3 |
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:
|
1 |
sudo passwd root |
puis on se connecte en tant que root avec la commande:
|
1 |
su |
Vérifiez que le dossier /root/.ssh existe (s’il n’existe pas: mkdir /root/.ssh)
Donnez-lui ces droits:
|
1 |
chmod 700 /root/.ssh |
Puis retourner dans $HOME/.ssh
|
1 |
cd $HOME/.ssh |
Envoyer les fichiers authorized_keys et id_rsa dans /root/.ssh
|
1 2 |
cp authorized_keys /root/.ssh cp id_rsa /root/.ssh |
Enfin on redémarre ssh:
|
1 |
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:
|
1 |
sudo apt-get install libttspico-utils |
test de création du fichier .wav et lecture du fichier:
|
1 2 |
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:
|
1 |
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:
|
1 |
groups pi |
Sinon on l’ajoute avec:
|
1 |
sudo usermod -a -G audio pi |
On va configurer le port du microphone et la carte audio:
|
1 |
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:
|
1 |
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:
|
1 2 |
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
- Mon projet s’est inspiré de : http://projectable.me/i-built-a-wifi-walkie-talkie-for-my-kids-now-you-can-too/ mais payant ou avec des pub
- alsa : https://wiki.debian.org/fr/ALSA
- synthétiseur vocal : https://www.framboise314.fr/donnez-la-parole-a-votre-raspberry-pi/
- connexion ssh : https://doc.ubuntu-fr.org/ssh
- scp sans mdp : https://geekeries.org/2016/10/transferts-scp-sans-mot-de-passe/
- module ampli : https://www.adafruit.com/product/1752
- boot sur disque dur : https://www.framboise314.fr/boot-simplifie-sur-usb-avec-les-raspberry-pi-1-2-et-3/
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 .
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 🙂
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 .
Re,
sleep c’est ce que je fais sur la dernière ligne du script 🙂
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
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 .
Merci pour ton boulot!
Je vais tester ce w-end 🙂
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 )
Bonjour Pascal,
Superbe et donne pleins d’idées
Bidouilleur mais pas seulement du Dimanche !!
Et la réalisation est au top
Merci pour ton commentaire, c’est ma femme qui dit bidouilleurs du dimanche car nos montages ne servent souvent pas à grand chose 😀
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
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?
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/
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
Salut Jojo,
ah oui je ne l’avais pas mis car le mien ne fonctionne pas encore comme j’aimerais, je veux tester avec un autre bouton encodeur mais je n’ai pas eu assez de temps.
Regarde ici qui me semble un bon tuto (en bas de la page):
http://npoulain.fr/raspberryPi-codeurRotatif-afficheur7segments-led
ou aussi ici:
https://guy.carpenter.id.au/gaugette/2013/01/14/rotary-encoder-library-for-the-raspberry-pi/
Nickel !
Je regarde ça dès que j’ai un peu de temps à moi.
Merci beaucoup Pascal !
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
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-distantePour é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.
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 🙂
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…
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..
Bonjour
J’ai 74 ans et essaye de passer mon temps en apprenant, j’ai donc comme intéret le raspi et pour bricoler il faut un target
Très intéressant le projet ,exactement ce que je recherche, je voudrais le réaliser,
Pourrais vous demander s’il était possible de m’envoyer par mail la dernière version du programme,car il y a eu des ajustements
ce qui m’éviterait des erreurs de retranscription etc
Je vous remercie et si je réalise le projet je vous enverrai mes commentaires de réalisation
bien à vous
luc
Bonjour Luc
je ne sais pas si Pascal, auteur de cet article pourra vous répondre.
Où avez vous vu qu’il y avait eu des modifs dans le programme ?
celui qui est dans l’article ne fonctionne pas ?
cdt
françois
vous pouvez copier le programme avec la barre du haut de sa zone, il y a une icone copie…
Bonjour Luc,
Normalement le script fonctionnera avec n’importe quelle version car il utilise simplement une connexion SSH et les commandes arecord/aplay.
Fais qques tests et je te répondrai volontiers par mail si tu rencontres des soucis 🙂
A++ Pascal
bonjour, très bon projet, je compte le refaire, est-ce tu pense que sa pourrait passer sur des Raspberry zéro ?
Salut,
Je dirais que oui, mais dit moi après avoir fait quelques tests 🙂
Ping : Présentation de la montre programmable TTGO - Framboise 314, le Raspberry Pi à la sauce française....
Bonjour à tous,
Je vais avoir l’air de déterrer un ancien article mais c’est pour la bonne cause !
J’ai un projet similaire mais pour une usage différent.
Je viens d’apprendre à mes dépends que non, tous les intercoms motos ne sont pas compatibles en eux… peu importe les dire des fabricants et vendeurs.
Le bluetooth est bien supposé proposer de la rétrocompatibilité, mais les vendeurs de chipset ont créés des modèles LTE non compatibles avec les non-LTE…
Mon but, idéalement, serait de faire communiquer deux framboises, en bluetooth ou en wifi, et chacun d’entre eux raccordés aux micro et oreillettes du casque.
Avantage : on peut jouer sur la puissance, s’affranchir de tout réseau
Inconvénient : c’est plus « lourd »
Verriez vous un problème à avoir les deux en full-duplex et non half-duplex : ne pas appuyer sur un bouton est important 🙂 ?