Éteindre un Raspberry Pi avec un simple

bouton
Il existe deux méthodes :

1. Une méthode scriptée

2. Une méthode de surcouche au démarrage

Description d'un bouton-poussoir

Le bouton-poussoir est un très simple composant électronique. Il est composé d'un simple circuit
interne connectant électriquement un première broche à une seconde broche si on appuie sur le
bouton.

Le bouton-poussoir a une très faible résistance interne. Pour cette raison, il est usuel de connecter
une broche de lecture via le bouton vers la masse plutôt que de lire une tension positive sur une
broche : dans ce dernier cas, vous devriez utiliser des résistances pour protéger votre broche de
lecture contre les défaillances de courant.

Dans son circuit interne, les broches opposées fonctionnent ensemble, tandis que l'appui sur le
bouton crée une interconnexion de circuits. Le circuit interne peut être schéma de cette manière :

Cela peut être un peu déroutant pour certaines personnes qui imaginent un simple bouton-poussoir
avec seulement 2 broches (au lieu de 4) connectées lorsque le bouton est enfoncé.
Le bouton-poussoir fournit une information logique (appuyé/relâché). Il doit donc être raccordé à une
broche en mode entré (“INPUT”).

Quand le bouton est relâché, pour ne pas laisser flottante l’entrée de la broche (cas d’un interrupteur
mécanique par exemple), il est nécessaire d’utiliser une résistance de rappel (pull down) ou de tirage
(pull up).

Les montages ci-dessous permettent de fournir à l'entrée de la broche les états :

Résistance de rappel Résistance de tirage

0V quand le bouton est relâché : état bas 3.3V quand le bouton est appuyé : état
= LOW bas = LOW
3.3V quand le bouton est appuyé : état 0V quand le bouton est relâché : état
haut = HIGH haut = HIGH

Un bouton n’est pas un objet parfait : lorsqu’on agit dessus (appuyer ou relâcher), le signal ne
commute pas parfaitement de 3.3V à 0V (ou le contraire). Il peut se passer quelques millisecondes
pendant lesquelles le signal va « rebondir » avant de se stabiliser. Ce rebond peut provoquer un
comportement inattendu du programme.
Une des solutions est d’utiliser un condensateur en parallèle avec le bouton. Ce composant permet
d’absorber les rebonds en se chargeant (ou se déchargeant) progressivement. La commutation du
port numérique n’a lieu qu’une fois le condensateur suffisamment chargé, soit un peu après la
commutation du bouton.

Le temps de charge du condensateur est déterminé par la relation :

t(s) = R(Ω) × C(F)

Mais, à mesure que le condensateur se charge, la tension à ses bornes augmente et,
conséquemment, la tension aux bornes de R diminue. La loi d’Ohm implique que le courant
remplissant le condensateur diminue. Si bien qu’au bout du temps t, le condensateur n’est chargé
qu’au deux tiers environ de la tension présente à ses bornes (63,21% exactement). Au bout de t, on a
UC = (2/3) × U avec U=3.3 Volts, soit une tension aux bornes du bouton-poussoir d'environ 2
Volts. La tension pour laquelle l'état de la broche est défini comme haut. Au bout de 2t, la tension aux
bornes du condensateur sera de (8/9) × U . A 3t, on aura (26/27) × U , etc..

Au bout de 5t (plus de 99%), le condensateur est considéré comme chargé. Le raisonnement est
inverse pour la décharge : à chaque constante de temps, le condensateur se vide du tiers de la
tension restant à ses bornes. Au bout de t, il reste (1/3) × U ; au bout de 2t, il reste (1/9) × U , etc..
Au bout de 5t, la tension résiduelle est inférieure à 1% de la tension d’origine, le condensateur s’est
vidé !

En utilisant un condensateur de 10 nF et une résistance de 10k Ohms, le bouton-poussoir est à l'état

haut au bout de 100 µs.

La version scriptée

Le script python interrogera la broche GPIO désignée et initiera l'arrêt du système si elle est abaissée
(court-circuitée) pendant plus de 0,5 seconde.
Dépendances
Le script utilise gpiozero qui simplifie l'interface des périphériques GPIO avec Raspberry Pi.

Instructions

Recopiez le script “rebooter.py” dans /usr/bin/rebooter.py

Recopiez le script “rebooter.service” dans /lib/systemd/system/rebooter.service
Installez rebooter.service :
sudo systemctl daemon-reload
sudo systemctl enable rebooter
sudo systemctl start rebooter

Scripts

rebooter.py
 Python
#!/usr/bin/python3

from gpiozero import Button

from time import sleep
from os import system, getuid
from sys import stdout, exit

stopPin = 26
stopButton = Button(stopPin) # defines the button as an object and chooses GPIO pin

def isRoot():
if getuid() != 0:
return False
else:
return True

def main():
print("\nMonitoring pin {} for reboot signal.".format(stopPin))
print("Ctrl-C to quit.\n")

try:
while (True):
if stopButton.is_pressed:
sleep(0.5)
if stopButton.is_pressed:
system("shutdown now -h")
sleep(0.1)

except KeyboardInterrupt:
print('\n\nKeyboard interrupt.')

finally:
pass

return

if __name__ == "__main__":
if not (isRoot()):
print("\nScript must be run as root.")
exit(1)
else:
main()
exit(0)

rebooter.service
 TypeScript
[Unit]
Description=Rebooter Service
After=multi-user.target

[Service]
Type=simple
ExecStart=/usr/bin/python3 /usr/bin/rebooter.py

[Install]
WantedBy=multi-user.target

Surcouche au démarrage du système

Dans la version 225 et supérieure du système, l'arrêt et la mise sous tension sont possibles en court-
circuitant la broche 5 du GPIO GPIO3. Cette fonctionnalité est activée en ajoutant la ligne suivante au
fichier /boot/config.txt et en redémarrant :

TypeScript
dtoverlay=gpio-shutdown,gpio_pin=3

Note : le qualificatif gpio_pin=3 est redondant car cette broche est la valeur par défaut.

La broche GPIO3 dispose d'une résistance de tirage externe, donc un court-circuitage à la masse
brièvement déclenchera une extinction. Un court-circuitage ultérieur à la masse (tant que
l'alimentation est toujours connectée) redémarrera le système.

La documentation de cette fonction est la suivante :

Nom : gpio-shutdown
Info : Déclenche une extinction lorsque l'état de la broche GPIO change.
La broche GPIO spécifiée est configurée comme une commande d'entrée
qui génère des événements KEY_POWER.

Cet événement est géré par systemd-logind en initiant une extinction.

Les versions de systemd antérieures à 225 nécessitent une règle udev
pour activer l'écoute sur le périphérique d'entrée :

ACTION!="REMOVE", SUBSYSTEM=="input", KERNEL=="event*", \

SUBSYSTEMS=="platform", DRIVERS=="gpio-keys", \
ATTRS{keys}=="116", TAG+="power-switch"

Alternativement, cet événement peut également être géré sur des

systèmes sans systemd, simplement par le démon d'initialisation
traditionnel SysV. L'événement KEY_POWER (code de commande 116)
doit être attribué à KeyboardSignal sur la console, puis l'action
kb::kbrequest de inittab, déclenchée par KeyboardSignal depuis
la console, peut être configurée pour déclencher l'extinction du
système. Voici les étapes de configuration pour cela :

Ajoutez les lignes suivantes au fichier /etc/console-setup/remap.inc :

 # Key Power as special keypress
keycode 116 = KeyboardSignal

Ensuite ajoutez les lignes suivantes au fichier /etc/inittab :

# Action on special keypress (Key Power)

kb::kbrequest:/sbin/shutdown -t1 -a -h -P now

Et enfin, rechargez la configuration en exécutant les commandes suivantes :

# dpkg-reconfigure console-setup
# service console-setup reload
# init q

Cette surcouche ne gère que l'extinction. Après l'extinction, le système peut

être rallumé en mettant la broche GPIO3 à l'état bas. La configuration par
défaut utilise GPIO3 avec une résistance de tirage, donc si vous connectez un
bouton entre GPIO3 et GND (broches 5 et 6 sur l'en-tête de 40 broches), vous
avez un bouton pour l'extinction et le rallumage. Veuillez noter que le
Raspberry Pi 1 Model B rev 1 utilise GPIO1 au lieu de GPIO3.

Commande : dtoverlay=gpio-shutdown,<param>=<val>
Paramètres : gpio_pin Broche GPIO pour déclencher (par défaut 3)
Pour le modèle Raspberry Pi 1 B rev 1,
définissez explicitement cette valeur sur 1,
par exemple :

dtoverlay=gpio-shutdown,gpio_pin=1

active_low Lorsque cette valeur est définie à 1 (actif bas),

une transition de niveau bas génère un événement
de touche enfoncée (key down), et une transition
de niveau haut génère un événement de touche
relâchée (key up). Lorsque cette valeur est
définie à 0 (actif haut), cela est inversé. La
valeur par défaut est 1 (actif bas).

gpio_pull État souhaité de la résistance de rappel

(off, down, up). La valeur par défaut est
"up" (résistance de tirage).

Notez que la broche par défaut (GPIO3) a une

résistance de tirage externe. Idem pour la
broche GPIO1 sur le modèle Raspberry Pi 1 B
rev 1.

debounce Spécifiez l'intervalle anti-rebond en millisecondes

(par défaut 100)