Utilisation du Raspberry Pi pour contrôler l'énergie électrique alternative

NOTE TRÈS IMPORTANTE : CECI N'EST PAS UN TUTORIEL. Cet article explique comment l'auteur a utilisé un Raspberry Pi pour contrôler un courant électrique. Cependant, l'auteur n'est PAS électricien et le fait qu'il ait réalisé cette expérience ne signifie pas que VOUS devriez la reproduire, surtout si vous ne savez pas comment effectuer des branchements électriques en toute sécurité. UN BRANCHEMENT INCORRECT PEUT ENTRAÎNER UN INCENDIE, DES DÉGÂTS MATÉRIELS, DES BLESSURES CORPORELLES, VOIRE LA MORT ! Par conséquent, NE reproduisez PAS aveuglément les étapes décrites par l'auteur, à moins d'être absolument certain de savoir ce que vous faites et d'être prêt à assumer l'entière responsabilité de vos actes ! Cet article est uniquement destiné à des fins INFORMATIVES et de discussion, et ne constitue en aucun cas un guide pour la construction d'un quelconque appareil !

Nous déclinons toute responsabilité en cas de tentative de construction basée sur les informations de cet article et pouvant entraîner des blessures ou des dommages matériels. Si vous n'êtes pas disposé à assumer l'entière responsabilité de vos actes, veuillez cesser immédiatement votre lecture. Ce document relate uniquement les actions de son auteur et ne vous encourage en aucun cas à les reproduire, surtout si vous ne mesurez pas pleinement les dangers liés à la manipulation de courant électrique sous tension. Veuillez consulter un électricien qualifié avant toute construction utilisant le réseau électrique domestique.

Nous cherchions à déterminer s'il était possible d'utiliser un Raspberry Pi pour contrôler un appareil alimenté en 120 volts CA. Notre première idée consistait à construire un dispositif basé sur ce schéma de câblage, qui nous aurait permis de contrôler deux prises électriques individuellement, en utilisant les broches GPIO 17 et 18 du Raspberry Pi. Nous avons essayé un relais statique de 25 ampères au lieu de celui de 40 ampères indiqué sur le schéma, mais le câblage des deux appareils reste identique (cliquez sur le schéma pour l'agrandir).

Nous avons constaté que la méthode décrite ci-dessus fonctionnait à condition d'utiliser des relais statiques de bonne qualité. Malheureusement, sur les deux relais que nous avons achetés, un seul était compatible avec le Raspberry Pi. Bien que la tension de déclenchement nominale indiquée soit de 3 à 32 volts CC, nous avons constaté que l'un des relais nécessitait une tension plus proche de 4 volts pour se déclencher. Nous avons ensuite trouvé d'autres témoignages d'acheteurs de ce type de relais rencontrant des problèmes similaires. Certains ont pu en acheter plusieurs et tous les relais fonctionnaient, tandis que d'autres, moins chanceux, ont rencontré les mêmes problèmes que nous.

Nous avons renvoyé le relais défectueux pour obtenir un remboursement et avons cherché une autre solution. Nous constatons cependant que certains relais statiques, comme ceux illustrés sur le schéma, peuvent supporter jusqu'à 40 ampères, à condition d'utiliser un dissipateur thermique adapté. Même les modèles les moins chers que nous avons achetés supportent jusqu'à 25 ampères avec un dissipateur thermique. Si nous avions dû contrôler une charge importante, nous aurions peut-être été disposés à en commander un autre pour le tester. Il est fort probable que ces relais fonctionneraient mieux avec l'ajout d'un transistor et d'une résistance appropriés au circuit de commande (en connectant une broche du transistor à l'alimentation +5 V du Raspberry Pi). Toutefois, n'étant pas ingénieurs en électronique, nous n'avons pas cherché à concevoir un tel circuit.

Nous avons ensuite essayé ceci :

Le circuit décrit ci-dessus utilise une carte de relais statique SainSmart à 2 canaux (5 V) . Contrairement aux relais statiques mentionnés précédemment, ce module nécessite une alimentation de +5 V, mais seulement une tension de déclenchement de 2,5 V à 20 V. Nous en avons acheté un, l'avons testé et n'avons rencontré aucun problème pour le déclencher depuis un Raspberry Pi.

Le seul inconvénient est que ces appareils ne supportent que 2 ampères (volts x ampères = watts ; ainsi, avec une tension de 110 volts, vous pourriez théoriquement alimenter une charge allant jusqu'à 220 watts. N'oubliez pas que les moteurs et certains autres appareils peuvent consommer plusieurs fois leur puissance nominale pendant une ou deux secondes au démarrage). Nous souhaitions uniquement alimenter des appareils consommant au maximum une vingtaine de watts ; la limitation à 2 ampères n'était donc pas un problème.

MISE À JOUR 26 août 2013 : Un lien vers cet article a été partagé sur Reddit (par une personne autre que nous). Dans les commentaires, l’article a été critiqué pour la présentation d’une prise de courant standard dans un circuit limité à 2 ampères. Un internaute l’a qualifié d’« article plutôt irresponsable » et a souligné qu’« utiliser une prise de 2 ampères, même d’apparence normale et sans dispositif de coupure en cas de surcharge, est une très mauvaise idée et risque de provoquer un incendie. Il est facile de dépasser 2 ampères. » Cependant, comme l’a fait remarquer un autre utilisateur, il est difficile de trouver des prises spécifiques conçues pour les faibles charges. Nous présentons cette prise uniquement à titre d’illustration, pour montrer comment un petit appareil, par exemple un appareil alimenté par un adaptateur secteur classique consommant seulement quelques watts, pourrait être utilisé. Les schémas ci-dessus sont fournis à titre conceptuel et illustratif uniquement. Nous ne vous conseillons en aucun cas de réaliser un tel circuit ni d'utiliser ce type de prise. Toutefois, si vous décidez malgré tout de le faire et d'en assumer tous les risques, nous vous recommandons vivement d'apposer une étiquette bien visible indiquant l'intensité et la puissance maximales (par exemple : intensité maximale de 2 ampères / 220 watts par prise, ou toute autre valeur appropriée au circuit que vous réalisez). Il serait également judicieux d'installer une protection, telle qu'un fusible de 2 ampères ou un disjoncteur, sur chaque phase du circuit entre le côté sous tension de la prise et la carte du module relais statique. Encore une fois, cet article n'est pas, et n'a jamais été, un guide de montage électronique. Par conséquent, si vous tentez de réaliser un tel montage, assurez-vous de bien maîtriser les aspects techniques.

D'ailleurs, SainSmart fabrique également ces cartes de modules de relais statiques en modèles à 4 et 8 canaux.

Nous étions un peu inquiets quant à la capacité de l'alimentation du Raspberry Pi à supporter la charge supplémentaire. D'après la description sur le site SainSmart, la carte que nous avons utilisée nécessite 5 volts CC à 160 mA. Sur le site web de Raspberry Pi, on peut lire : « Les utilisateurs du modèle B qui utilisent des périphériques réseau et USB à forte consommation auront besoin d'une alimentation capable de fournir 700 mA (de nombreux chargeurs de téléphone répondent à cette exigence). Les utilisateurs du modèle A avec des périphériques USB alimentés pourront se contenter d'une alimentation de capacité bien inférieure (300 mA nous semblent une marge de sécurité raisonnable). » Nous n'utilisons aucun périphérique USB, et encore moins un périphérique à forte consommation, et notre alimentation fournit 1 000 mA (1 ampère). Il semblerait donc que la consommation électrique soit largement inférieure à sa capacité. De plus, nous n'avons rencontré aucun problème d'alimentation.

REMARQUE : Les appareils représentés sur les schémas ne sont PAS à l'échelle.

Contrôle de l'appareil :

Le contrôle de l'appareil se résume à activer ou désactiver les broches GPIO. Nous avons créé quelques scripts bash simples pour cela :

Pour GPIO17 (nom de fichier /root/gpio17.sh) :

#!/bin/bash

si [ -z $1 ]
alors
opt="bascule"
elif [ -n $1 ]
alors
opt=1 $
fi

soit "dormir = $RANDOM + 10000"
dormir "0.$sommeil"

si [ $(pgrep gpio17.sh|wc -w) -gt "2" ]; alors
sortie
fi

si [ ! -e "/sys/class/gpio/gpio17/value" ]
alors
echo "17" > /sys/class/gpio/export
afficher "out" > /sys/class/gpio/gpio17/direction
fi

cas $opt dans
sur)
echo 1 > /sys/class/gpio/gpio17/value
;;
désactivé)
echo 0 > /sys/class/gpio/gpio17/value
;;
basculer)
valeur=`cat /sys/class/gpio/gpio17/value`
si [ $value -ne 0 ]
alors
echo 0 > /sys/class/gpio/gpio17/value
autre
echo 1 > /sys/class/gpio/gpio17/value
fi
;;
redémarrer)
echo 0 > /sys/class/gpio/gpio17/value
dormir 30
echo 1 > /sys/class/gpio/gpio17/value
;;
statut)
sortie
;;
*)
echo "Option invalide - utilisez on, off, toggle ou reboot (toggle est l'option par défaut)."
sortie
;;
esac

dormir 3

Et pour GPIO18 (nom de fichier /root/gpio18.sh) :

#!/bin/bash

si [ -z $1 ]
alors
opt="bascule"
elif [ -n $1 ]
alors
opt=1 $
fi

soit "dormir = $RANDOM + 10000"
dormir "0.$sommeil"

si [ $(pgrep gpio18.sh|wc -w) -gt "2" ]; alors
sortie
fi

si [ ! -e "/sys/class/gpio/gpio18/value" ]
alors
echo "18" > /sys/class/gpio/export
afficher "out" > /sys/class/gpio/gpio18/direction
fi

cas $opt dans
sur)
echo 1 > /sys/class/gpio/gpio18/value
;;
désactivé)
echo 0 > /sys/class/gpio/gpio18/value
;;
basculer)
valeur=`cat /sys/class/gpio/gpio18/value`
si [ $value -ne 0 ]
alors
echo 0 > /sys/class/gpio/gpio18/value
autre
echo 1 > /sys/class/gpio/gpio18/value
fi
;;
redémarrer)
echo 0 > /sys/class/gpio/gpio18/value
dormir 30
echo 1 > /sys/class/gpio/gpio18/value
;;
statut)
sortie
;;
*)
echo "Option invalide - utilisez on, off, toggle ou reboot (toggle est l'option par défaut)."
sortie
;;
esac

dormir 3

Assurez-vous de rendre les scripts exécutables. Si vous souhaitez contrôler d'autres broches GPIO, copiez le texte de l'un des scripts ci-dessus dans un éditeur de texte (qui ne modifie pas les fins de ligne), puis effectuez une recherche et un remplacement globaux pour le numéro de broche. Par exemple, si vous utilisez le script pour la broche 18 et que vous souhaitez contrôler la broche 4, remplacez toutes les occurrences de « 18 » par « 4 », puis enregistrez le script sous le nom /root/gpio4.sh et rendez-le exécutable. Outre les broches 4, 17 et 18, vous pouvez également utiliser les numéros 22, 23, 24, 25 et 27 (sur une carte de révision 2). Si vous possédez une carte de révision 1, remplacez le numéro 27 par le numéro 21. Si la numérotation des broches GPIO du Raspberry Pi vous semble totalement incohérente, rassurez-vous, vous n'êtes pas le seul : ces numéros ne suivent aucune logique et ne correspondent en rien à la position des broches sur la carte. Le mieux est de consulter un tableau comme celui-ci pour vous y retrouver.

(À proprement parler, il est possible de contrôler d'autres broches du Raspberry Pi, mais les huit broches GPIO mentionnées précédemment sont à privilégier pour tout projet de ce type. Le contrôle des autres broches dépasse le cadre de cet article. Notez également que les schémas de câblage ci-dessus concernent des cartes de révision 2, dont le brochage diffère légèrement de celui des cartes de révision 1. Toutefois, les broches utilisées pour le câblage dans ces schémas restent identiques entre les révisions. Cet article suppose que vous disposez d'une carte de révision 2. Si vous possédez une carte de révision 1, remplacez toute référence à la broche 27 par la broche 21.)

Les scripts acceptent quatre arguments : on, off, toggle ou reboot (ils acceptent également un cinquième argument, status, mais celui-ci a une utilité particulière et n’est pas destiné à être utilisé directement depuis l’invite de commandes). L’option toggle est utilisée par défaut si aucun argument n’est spécifié.

Il y a une petite section en haut de chaque script qui peut dérouter certains lecteurs :

soit "dormir = $RANDOM + 10000"
dormir "0.$sommeil"

si [ $(pgrep gpio17.sh|wc -w) -gt "2" ]; alors
sortie
fi

Cette section introduit un délai aléatoire (de 0,1 à 0,42767 seconde), puis vérifie si le script est déjà en cours d'exécution, sans rien écrire sur la carte SD du Raspberry Pi (ce qui pourrait réduire sa durée de vie en cas d'utilisation trop fréquente). Si le script est déjà en cours d'exécution, elle s'arrête. Bien qu'il soit peu probable qu'un utilisateur tente de lancer le même script deux fois, cette précaution permet de l'éviter. C'est également le rôle du « sleep 3 » à la fin du script : empêcher l'activation ou la désactivation trop rapide des périphériques. Si vous connaissez une meilleure façon de procéder, n'hésitez pas à modifier le script et à partager vos suggestions dans les commentaires (mais, merci de ne pas suggérer de consulter les pages de manuel. Si c'est tout ce que vous avez à offrir, passez votre chemin).

La raison pour laquelle nous avons utilisé deux scripts pour les deux broches, plutôt qu'un seul avec une option supplémentaire permettant de spécifier quelle broche contrôler, est de vous permettre de contrôler simultanément les deux broches sans vous voir refuser l'accès à l'une parce que le script est déjà en cours d'exécution sur l'autre.

Les options devraient être assez évidentes :

allumer – tourner la broche sur
Éteindre – éteignez la broche
bascule – si la broche est actuellement éteinte, l'allumer, et inversement (c'est le comportement par défaut si aucune option n'est spécifiée)
Redémarrage – coupez le contact pendant 30 secondes, puis remettez-le en marche

La commande cachée, « status », est une commande vide qui vérifie simplement l'initialisation de la broche sans en modifier l'état. Elle est conçue pour être utilisée lors de l'appel de ce script depuis Asterisk. Oui, c'est possible, une fois les scripts ci-dessus activés et leur bon fonctionnement confirmé !

Contrôle du périphérique depuis Asterisk/FreePBX :

Cette section suppose que le Raspberry Pi exécute Asterisk pour Raspberry Pi (RasPBX), mais elle devrait fonctionner avec toute autre distribution basée sur FreePBX exécutée sur le Raspberry Pi. Pour permettre à Asterisk de contrôler les broches GPIO, vous pouvez ajouter les lignes suivantes au fichier /etc/asterisk/extensions-custom.conf (notez que cela nécessite quelques enregistrements personnalisés et une configuration supplémentaire, qui seront abordés plus loin) :

[custom-picontrol]
exten => s,1,Set(TIMEOUT_LOOPCOUNT=0)
exten => s,n,Set(INVALID_LOOPCOUNT=0)
exten => s,n,Set(_IVR_CONTEXT_${CONTEXT}=${IVR_CONTEXT})
exten => s,n,Set(_IVR_CONTEXT=${CONTEXT})
exten => s,n,Set(__IVR_RETVM=)
exten => s,n,GotoIf($["${CDR(disposition)}" = "ANSWERED"]?skip)
exten => s,n,Réponse
exten => s,n,Attendre(1)
exten => s,n(skip),Set(IVR_MSG=custom/veuillez-entrer-rpi-pin)
exten => s,n(début),Set(TIMEOUT(chiffre)=3)
exten => s,n,Set(PIGPIOPIN=Background(${IVR_MSG}))
exten => s,n,ExecIf($["${IVR_MSG}" != ""]?Background(${IVR_MSG}))
exten => s,n,AttendreExten(5,)
exten => 4,1(ivrsel-4),Set(PIGPIOPIN=4)
exten => 4,n,Goto(custom-validpipin,s,1)
exten => 17,1(ivrsel-17),Set(PIGPIOPIN=17)
exten => 17,n,Goto(custom-validpipin,s,1)
exten => 18,1(ivrsel-18),Set(PIGPIOPIN=18)
exten => 18,n,Goto(custom-validpipin,s,1)
exten => 22,1(ivrsel-22),Set(PIGPIOPIN=22)
exten => 22,n,Goto(custom-validpipin,s,1)
exten => 23,1(ivrsel-23),Set(PIGPIOPIN=23)
exten => 23,n,Goto(custom-validpipin,s,1)
exten => 24,1(ivrsel-24),Set(PIGPIOPIN=24)
exten => 24,n,Goto(custom-validpipin,s,1)
exten => 25,1(ivrsel-25),Set(PIGPIOPIN=25)
exten => 25,n,Goto(custom-validpipin,s,1)
exten => 27,1(ivrsel-27),Set(PIGPIOPIN=27)
exten => 27,n,Goto(custom-validpipin,s,1)
exten => i,1,Set(INVALID_LOOPCOUNT=$[${INVALID_LOOPCOUNT}+1])
exten => i,n,GotoIf($[${INVALID_LOOPCOUNT} > 3]?final)
exten => i,n,Set(IVR_MSG=custom/désolé-non-valide-rpi-gpio)
exten => i,n,Goto(s,start)
exten => i,n(final),Playback(transfert de réponse non valide)
exten => i,n,Goto(app-blackhole,hangup,1)
exten => t,1,Set(TIMEOUT_LOOPCOUNT=$[${TIMEOUT_LOOPCOUNT}+1])
exten => t,n,GotoIf($[${TIMEOUT_LOOPCOUNT} > 3]?final)
exten => t,n,Set(IVR_MSG=no-valid-response-pls-try-again&custom/please-enter-rpi-pin)
exten => t,n,Goto(s,start)
exten => t,n(final),Playback(transfert de réponse non valide)
exten => t,n,Goto(app-blackhole,hangup,1)
exten => return,1,Set(_IVR_CONTEXT=${CONTEXT})
exten => return,n,Set(_IVR_CONTEXT_${CONTEXT}=${IVR_CONTEXT_${CONTEXT}} )
exten => return,n,Set(IVR_MSG=custom/veuillez-entrer-rpi-pin)
exten => retour,n,Aller à(s,début)
exten => h,1,Raccrocher
exten => hang,1,Playback(vm-goodbye)
exten => raccrocher,n,Raccrocher

[custom-validpipin]
exten => s,1,Set(TIMEOUT_LOOPCOUNT=0)
exten => s,n,Set(INVALID_LOOPCOUNT=0)
exten => s,n,Set(_IVR_CONTEXT_${CONTEXT}=${IVR_CONTEXT})
exten => s,n,Set(_IVR_CONTEXT=${CONTEXT})
exten => s,n,Set(__IVR_RETVM=)
exten => s,n,GotoIf($["${CDR(disposition)}" = "ANSWERED"]?skip)
exten => s,n,Réponse
exten => s,n,Attendre(1)
exten => s,n(skip),Set(IVR_MSG=custom/rpi-gpio-pin-state-selection)
exten => s,n(début),Set(TIMEOUT(chiffre)=3)
exten => s,n,ExecIf($["${IVR_MSG}" != ""]?Background(${IVR_MSG}))
exten => s,n,AttendreExten(5,)
exten => 0,1(ivrsel-0),Set(PIPINSTATE=off)
exten => 0,n,Goto(custom-pincontrol,s,1)
exten => 1,1(ivrsel-1),Set(PIPINSTATE=on)
exten => 1,n,Goto(custom-pincontrol,s,1)
exten => 2,1(ivrsel-1),Set(PIPINSTATE=toggle)
exten => 2,n,Goto(custom-pincontrol,s,1)
exten => 3,1(ivrsel-1),Set(PIPINSTATE=reboot)
exten => 3,n,Goto(custom-pincontrol,s,1)
exten => 4,1(ivrsel-1),Set(PIPINSTATE=status)
exten => 4,n,Goto(custom-pincontrol,s,1)
exten => i,1,Set(INVALID_LOOPCOUNT=$[${INVALID_LOOPCOUNT}+1])
exten => i,n,GotoIf($[${INVALID_LOOPCOUNT} > 3]?final)
exten => i,n,Set(IVR_MSG=no-valid-response-pls-try-again)
exten => i,n,Goto(s,start)
exten => i,n(final),Playback(transfert de réponse non valide)
exten => i,n,Goto(app-blackhole,hangup,1)
exten => t,1,Set(TIMEOUT_LOOPCOUNT=$[${TIMEOUT_LOOPCOUNT}+1])
exten => t,n,GotoIf($[${TIMEOUT_LOOPCOUNT} > 3]?final)
exten => t,n,Set(IVR_MSG=no-valid-response-pls-try-again&custom/rpi-gpio-pin-state-selection)
exten => t,n,Goto(s,start)
exten => t,n(final),Playback(transfert de réponse non valide)
exten => t,n,Goto(app-blackhole,hangup,1)
exten => return,1,Set(_IVR_CONTEXT=${CONTEXT})
exten => return,n,Set(_IVR_CONTEXT_${CONTEXT}=${IVR_CONTEXT_${CONTEXT}} )
exten => return,n,Set(IVR_MSG=custom/rpi-gpio-pin-state-selection)
exten => retour,n,Aller à(s,début)
exten => h,1,Raccrocher
exten => hang,1,Playback(vm-goodbye)
exten => raccrocher,n,Raccrocher

[contrôle de broche personnalisé]
exten => s,1,Noop(La broche GPIO sélectionnée est ${PIGPIOPIN} et l'état de la broche est ${PIPINSTATE})
exten => s,n,System(sudo /root/gpio${PIGPIOPIN}.sh ${PIPINSTATE})
exten => s,n,Playback(custom/pin)
exten => s,n,SayNumber(${PIGPIOPIN})
exten => s,n,Lecture(en/ha/is)
exten => s,n,ExecIf($["${SHELL(cat /sys/class/gpio/gpio${PIGPIOPIN}/value):0:1}" = "0"]?Playback(en/ha/off):Playback(en/ha/on))
exten => s,n,Goto(app-blackhole,hangup,1)
exten => h,1,Raccrocher

Le contexte [custom-picontrol] ci-dessus vous permet en réalité de saisir n'importe quelle broche GPIO disponible (accessible à l'utilisateur) du Raspberry Pi. Cependant, dans notre exemple, nous n'utilisons que les broches 17 et 18. Si vous ne prévoyez pas d'utiliser d'autres broches GPIO, vous pouvez supprimer toutes les lignes commençant par exten => N, où N est un nombre différent de 17 ou 18. Les deux premiers contextes sont basés sur la logique IVR de FreePBX, à la différence qu'au lieu d'utiliser la sélection pour transférer l'appel vers un poste ou une autre destination, les choix effectués sont stockés dans des variables pour être utilisés par le contexte [custom-pincontrol].

Pour que cela fonctionne, vous devez effectuer quelques étapes supplémentaires. Tout d'abord, vous devez autoriser Asterisk à exécuter les scripts. Ajoutez ces lignes à la fin du fichier /etc/sudoers :

astérisque TOUS = PAS DE PASSE : /root/gpio17.sh
astérisque TOUS = PAS DE PASSE : /root/gpio18.sh

Si vous souhaitez autoriser Asterisk à contrôler toutes les broches GPIO et non seulement les broches 17 et 18, voici la liste complète des lignes à ajouter au fichier /etc/sudoers. Notez que vous devez créer les scripts supplémentaires et les rendre exécutables :

astérisque TOUS = NOPASSWD : /root/gpio4.sh
astérisque TOUS = PAS DE PASSE : /root/gpio17.sh
astérisque TOUS = PAS DE PASSE : /root/gpio18.sh
astérisque TOUS = NOPASSWD : /root/gpio22.sh
astérisque TOUS = NOPASSWD : /root/gpio23.sh
astérisque TOUS = NOPASSWD : /root/gpio24.sh
astérisque TOUS = NOPASSWD : /root/gpio25.sh
astérisque TOUS = NOPASSWD : /root/gpio27.sh

Vous devez également créer des enregistrements système et les placer dans le répertoire /var/lib/asterisk/sounds/custom. Vous pouvez les ajouter à l'aide du module FreePBX System Recordings, ce qui est d'ailleurs la méthode recommandée car elle garantit que toutes les permissions sont correctement configurées. Voici les quatre nouveaux enregistrements nécessaires et les scripts suggérés :

please-enter-rpi-pin.wav : « Veuillez saisir le numéro de la broche GPIO du Raspberry Pi que vous souhaitez contrôler : »
rpi-gpio-pin-state-selection.wav : « Appuyez sur zéro pour désactiver la broche GPIO, sur un pour l’activer, sur deux pour la régler sur l’état inverse de son état actuel, sur trois pour lancer une séquence de redémarrage ou sur quatre pour entendre l’état actuel de la broche. »
sorry-not-valid-rpi-gpio.wav : « Désolé, ce n’est pas un numéro de broche GPIO valide pour Raspberry Pi. Veuillez réessayer. »
pin.wav : « Pin »

Si vous maîtrisez un logiciel de montage audio comme Audacity, vous pouvez probablement extraire le mot « Pin » d'un des enregistrements existants commençant par ce mot (disponibles dans /var/lib/asterisk/sounds/en pour les anglophones). Pour les autres, vous pouvez les enregistrer vous-même ou utiliser un logiciel de synthèse vocale. Vous pouvez également utiliser le logiciel de synthèse vocale flite s'il est installé sur votre système, mais vous devrez adapter les contextes en conséquence (nous n'apprécions pas la qualité sonore de flite, vous devrez donc vous débrouiller avec ce logiciel).

Enfin, vous devez accéder à FreePBX et, sous Admin/Destinations personnalisées, ajouter une destination personnalisée appelée « Contrôle Raspberry Pi », puis lui attribuer cette destination :

custom-picontrol,s,1

Ensuite, accédez à Applications/Applications diverses et ajoutez une nouvelle application diverse, par exemple « Contrôle Raspberry Pi ». Attribuez-lui un numéro de poste à utiliser pour contrôler les broches de votre Raspberry Pi ; nous avons utilisé 774 (« RPI » sur un clavier numérique standard). Dans la section Destination, sélectionnez « Destinations personnalisées » puis « Contrôle Raspberry Pi ». Appliquez ensuite les modifications et le tour est joué !

Autres moyens de contrôler les broches :

Il existe de nombreuses autres façons de contrôler les broches. Vous pouvez même le faire depuis un autre ordinateur de votre réseau. Par exemple, nous avons configuré des connexions SSH sans mot de passe depuis un autre ordinateur de notre réseau local. Une fois cela fait, nous pouvons créer sur cet ordinateur des scripts comme celui-ci (attention : ne les placez PAS sur le Raspberry Pi !) :

Dans ~/gpio17.sh, insérez ces deux lignes :

#!/bin/bash
ssh root@adresse_IP_du_Raspberry_Pi "/root/gpio17.sh $1"

Dans le fichier ~/gpio18.sh, insérez ces deux lignes :

#!/bin/bash
ssh root@adresse_IP_du_Raspberry_Pi "/root/gpio18.sh $1"

Remplacez IP_address_of_Raspberry_Pi par l'adresse IP de votre Raspberry Pi – bien sûr, cela fonctionne mieux si le Raspberry Pi est toujours sur la même adresse IP.

Nous pouvons désormais exécuter des scripts Bash depuis un autre système, comme si nous étions connectés au Raspberry Pi. L'avantage principal réside dans la possibilité d'appeler ces scripts depuis d'autres logiciels du système. Imaginons que cet autre système soit un PC home cinéma doté d'un fichier ~/.lircrc pour recevoir les commandes de la télécommande. Vous pourriez y ajouter des lignes comme celles-ci (notez que ces lignes dépendent de la télécommande utilisée et ne sont données qu'à titre d'exemple) :

commencer
prog = irexec
bouton = KEY_RED
config = ~/gpio17.sh &
répéter = 0
fin

commencer
prog = irexec
bouton = KEY_BLUE
config = ~/gpio18.sh &
répéter = 0
fin

Désormais, à chaque pression sur le bouton rouge de la télécommande, la broche GPIO17 du Raspberry Pi bascule dans l'état opposé à son état actuel (puisqu'aucune option n'est spécifiée). Et si vous appuyez sur le bouton bleu, c'est la broche GPIO18 qui bascule. Vous pouvez donc utiliser une télécommande d'un autre système pour envoyer des commandes au Raspberry Pi afin d'allumer ou d'éteindre un appareil. Vous pouvez également créer un script ou un programme qui active ou désactive des appareils à des moments précis. Nous l'avons déjà fait, et nous savons que cela fonctionne ! Les possibilités semblent infinies. J'imagine bien concevoir un système d'arrosage automatique pour pelouse qui téléchargerait les prévisions météorologiques et déciderait d'arroser ou non en fonction de la probabilité de fortes pluies. Ce n'est qu'un exemple parmi tant d'autres de ce que vous pourriez réaliser si vous avez les compétences et l'expertise nécessaires.

Encore une fois, si par imprudence vous ignorez nos conseils de ne pas tenter de construire quoi que ce soit de ce genre sans savoir comment vous protéger lorsque vous travaillez avec le courant électrique domestique, VEUILLEZ faire preuve d'une extrême prudence ! Nous serions vraiment désolés de voir quelqu'un se tuer ou se blesser, ou mettre le feu à sa maison (mais nous ne serons pas responsables si cela arrive, car nous vous avons avertis de toutes les manières possibles !).