jeudi 31 octobre 2019

ARDUINO : pilotage de ventilateurs


ARDUINO : pilotage de ventilateurs


Possédant une alimentation MATRIX MPS-3003D, j'ai le projet d'équiper son ventilateur beaucoup trop bruyant d'une régulation de vitesse.
Dans cet article nous allons essayer de piloter un ventilateur ou un ventirad 12V de PC en PWM à l'aide d'un ARDUINO.

Il existe trois types principaux de ventilateurs :
  • les ventilateurs 2 broches
  • les ventilateurs 3 broches
  • les ventilateurs 4 broches

1. Nombre de broches

Les ventilateurs 2 broches possèdent une broche GND et une broche 12V.

Les ventilateurs 3 broches possèdent une broche GND, une broche 12V et une broche tachymètre.

Les ventilateurs 4 broches possèdent une broche GND, une broche 12V, une broche tachymètre et une broche PWM.

La compatibilité est ascendante, c'est à dire que le brochage de ces ventilateurs avec le temps, au fur et à mesure de l'avancement des technologies, s'est adapté :

  • broche 1 : GND
  • broche 2 : +12V
  • broche 3 : tachymètre
  • broche 4 : PWM
On pourra donc brancher un ventilateur 2 broches ou 3 broches sur un connecteur 4 broches sans problème.

Le tachymètre est en général un capteur à effet hall fournissant une impulsion par tour de moteur.

1.1. Ventilateur 2 broches

On pourra faire varier la vitesse d'un ventilateur 2 broches en lui fournissant soit une tension continue variable soit une tension PWM.
L'électronique de pilotage devra supporter la puissance du ventilateur.
En général ce type de ventilateur accepte de démarrer à partir de 5V.

1.2. Ventilateur 3 broches

On pourra faire varier la vitesse d'un ventilateur 3 broches de la même façon qu'avec un ventilateur 2 broches. Le comportement est le même.

Si le pilotage est réalisé en PWM l'alimentation du tachymètre sera hachée à la même fréquence que celui-ci, et le signal produit par le capteur sera également haché, ce qui le rendra donc difficilement exploitable, sauf à sa vitesse maximale.

La seule solution avec un ventilateur 3 fils, si l'on veut exploiter l'information du tachymètre, est de l'alimenter à l'aide d'une source de tension continue et variable, un régulateur ajustable par exemple, dont on fera varier la tension de sortie à l'aide d'un amplificateur opérationnel et d'un microcontrôleur.
On peut s'inspirer de cet article :
https://www.edn.com/design/analog/4363990/Control-an-LM317T-with-a-PWM-signal

1.3. Ventilateur 4 broches

Un ventilateur 4 broches est pilotable en vitesse par une broche de commande PWM et possède sa propre électronique de puissance.
L'électronique de pilotage n'aura pas besoin de supporter la puissance du ventilateur, c'est à dire que l'on pourra relier la broche de commande PWM directement à la sortie d'un microcontrôleur.
L'information du tachymètre sera toujours facilement exploitable, car l'alimentation 12V est permanente.

1.4. Tensions et courants

Sauf exception les ventilateurs de PC fonctionnent sous 12V.

La tension issue du tachymètre est souvent de 12V, c'est à dire qu'elle ne sera pas directement acceptable par l'entrée d'un microcontrôleur. Il faudra limiter cette tension à un voltage acceptable par celui-ci.
Il est souvent indispensable d'ajouter une résistance de charge entre la broche 12V et la sortie tachymètre pour obtenir un signal.

La tension maximale de l'entrée PWM d'un ventilateur 4 broches est en général de 3.3V.
Si la broche PWM est laissée en l'air un ventilateur 4 broches tourne à sa vitesse maximale. On obtient donc le comportement d'un ventilateur 2 ou 3 broches.
Cela veut dire que lorsque notre microcontrôleur va démarrer le ventilateur sera lancé à plein régime.
On peut éviter cela en ajoutant une résistance de 10KΩ entre broche PWM et GND. Comme nous devons réduire la tension PWM, nous utiliserons un pont diviseur 50% : 10KΩ + 10KΩ, ce qui permettra d'assurer les deux fonctions.

La puissance d'un ventilateur de PC est faible : quelques watts. Un gros ventilateur de 120mm consommera environ 200mA, soit 2.4W.
Un petit transistor 2N2222 supporte 800mA et suffira amplement à piloter un ventilateur 2 broches ou 3 broches.
S'il est correctement saturé sa tension Vce sera de 50mV au maximum. La puissance dissipée sera de 0.05V * 0.2A = 10mW.
On peut également utiliser un petit MOSFET, un BS170 par exemple. Voir ici :
https://riton-duino.blogspot.com/2018/08/alimenter-un-relais-transistor.html
Paragraphe 4. Le transistor unipolaire

1.5. PWM

Un ventilateur 4 broches fonctionne normalement avec une fréquence PWM de 25KHz.
Avec un ARDUINO, nous sommes limités par le nombre de rapports de division possible des timers utilisés. Nous utiliserons plutôt une fréquence de 31KHz. La broche utilisée devra être capable de générer cette fréquence. Avec un ATMEGA328, les broches D3, D9, D10 et D11 conviennent. Avec un ATMEGA2560 le choix est plus large.

Le sujet est expliqué ici : https://arduinoinfo.mywikis.net/wiki/Arduino-PWM-Frequency

Cette fréquence n'est pas une obligation, c'est une norme. Techniquement le ventilateur fonctionnera même à la fréquence par défaut du PWM de la librairie ARDUINO (500Hz, ou 1kHz pour les pins D5 et D6).
Un ventilateur 4 broches fonctionnera à 500Hz, un ventilateur à 2 ou 3 broches produira pratiquement à coup sûr un sifflement audible.
Les deux modèles 4 broches Freezer et Scythe que j'ai essayé fonctionnent aussi bien à 500Hz qu'à 31KHz, par contre les quelques modèles 2 broches et 3 broches que j'ai testé sifflent tous à 500Hz.

Un ventilateur 4 broches tourne même avec un rapport PWM de 0%. Le circuit interne au ventilateur le fait simplement tourner à sa vitesse minimale, ce qui est plutôt intéressant.
Certains modèles ne parviennent cependant pas à démarrer avec un facteur de PWM faible, mais ils sont capables de tourner avec un rapport de 0% après avoir été lancés avec un rapport PWM plus élevé.
Je n'ai pas testé un nombre suffisant de ventilateurs pour affirmer que ce sera le cas avec tous les modèles.

Cela ne sera pas le cas avec un ventilateur 2 ou 3 broches. Nous devrons gérer nous même cet aspect.
Pas mal de ventilateurs commencent à tourner avec un rapport PWM de 40% et s'arrêtent si le rapport PWM descend en dessous de 30%.
Le logiciel devra éviter d'utiliser un rapport PWM inférieur, sauf 0% bien entendu pour couper le ventilateur.
Chaque ventilateur est différent, il faudra expérimenter. Le sketch fourni en fin d'article peut aider à déterminer ces valeurs minimales.

2. le schéma

2.1. Ventilateur 2 ou 3 broches


Comme avec toute charge inductive le transistor est protégé par une diode de roue libre.

2.2. Ventilateur 4 broches


3. Le code

Le code ci-dessous permet de piloter des ventilateurs 2, 3 ou 4 broches en PWM sur la broche D3. Il suffit de changer la valeur de la constante FAN_WIRES.
La broche D2 est utilisée en source d'interruption pour mesurer la vitesse (ventilateur à 4 broches uniquement). La vitesse est mesurée toutes les secondes.
 
#define FAN_WIRES   4
#define PWM_PIN     3
#define SENSOR_PIN  2

#if FAN_WIRES == 4
volatile unsigned int revs;
#endif

void setup()
{
  Serial.begin(115200);
  Serial.println("FAN CONTROL");

  // prescaller for 31.372KHz
  TCCR2B &= B11111000;
  TCCR2B |= (0 << CS22) | (0 << CS21) | (1 << CS20);
  digitalWrite(PWM_PIN, LOW);
  pinMode(PWM_PIN, OUTPUT);
#if FAN_WIRES == 4
  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), interruptHandler, FALLING);
#endif
}

void loop()
{
  int pwm, pwmGpio;

  for (pwm = 0 ; pwm <= 100 ; pwm += 10) {
    Serial.print(pwm);
    Serial.print("%: (");
    pwmGpio = pwm * 2.5;
    Serial.print(pwmGpio);
    Serial.print(") ");
    analogWrite(PWM_PIN, pwmGpio);
    delay(2000);
#if FAN_WIRES == 4
    Serial.print(" speed = "); Serial.println(getSpeed());
#else
    Serial.println();
#endif
  }
  for (pwm = 90 ; pwm >= 0 ; pwm -= 10) {
    Serial.print(pwm);
    Serial.print("%: (");
    pwmGpio = pwm * 2.5;
    Serial.print(pwmGpio);
    Serial.print(") ");
    analogWrite(PWM_PIN, pwmGpio);
    delay(2000);
#if FAN_WIRES == 4
    Serial.print(" speed = "); Serial.println(getSpeed());
#else
    Serial.println();
#endif
  }
}

#if FAN_WIRES == 4

unsigned int getSpeed()
{
  static unsigned long lastMillis;
  static unsigned int lastRead;
  unsigned long elapsed = millis() - lastMillis;
  if (elapsed > 1000) {
    detachInterrupt(digitalPinToInterrupt(SENSOR_PIN));
    double correctionFactor = 1000.0 / elapsed;
    lastRead = correctionFactor *
revs / 2 * 60;
   
revs = 0;
    lastMillis = millis();
    attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), interruptHandler, FALLING);
    return lastRead;
  }
}

void interruptHandler(void)
{
 
revs++;
}

#endif


4. Conclusion

Ce n'est pas la première fois que je pilote des ventilateurs 2 broches et 3 broches en PWM, mais ce petit sujet a été l'occasion pour moi d'expérimenter les ventilateurs 4 broches et de mettre en évidence certaines comportements inattendus de ceux-ci, bien plus intelligents qu'il n'y paraît.


Cordialement
Henri

jeudi 24 octobre 2019

RASPBERRY PI : UPS DFRobot DFR0494



RASPBERRY PI : UPS DFRobot DFR0494


Vous savez probablement que lorsque l'on coupe la tension d'une RASPBERRY PI il peut arriver que l'on détériore le système de fichiers de la µSD, lors d'un accès en écriture notamment.
Cela peut arriver bien évidemment lors d'une coupure ou d'une micro-coupure secteur.
La première solution qui vient à l'esprit est l'onduleur.

Il existe plusieurs solutions :
  • onduleur classique
  • powerbank onduleur
  • cartes spécialisées

1. Onduleur

Un onduleur classique est volumineux et cher.

2. Power-Bank

Tous les power-banks ne conviennent pas. Il faut en effet que la fonction recharge et la fonction alimentation soient disponibles simultanément. C'est rarement la cas.
On en parle ici : https://www.iotera.fr/batteries-externes-avec-fonction-onduleur-pour-votre-box-jeedom-ou-raspberry/

J'ai essayé cette solution :

Ce mini-chargeur semble bien pratique mais ne pourra hélas pas être utilisé comme UPS. Lorsque l'on débranche l'alimentation secteur, l'alimentation de la RASPBERRY PI est coupée.
Par contre il peut être utilisé sans problème comme alimentation portative.

3. Cartes spécialisées

Il existe des cartes spécialisées enfichables sur la RASPBERRY PI. J'ai essayé la DFRobot DFR0494 (prix : 18.50€ chez GoTronic).

Cette carte a été testée plus en profondeur dans un autre article :
https://riton-duino.blogspot.com/2020/02/raspberry-pi-ups-dfrobot-dfr0494-en-test.html

3.1. Mise en œuvre

Attention : je pense qu'il est préférable de ne pas enficher la carte équipée de sa batterie sur la RASPBERRY PI. J'ai préféré enficher la carte et insérer la batterie ensuite.

Après déballage, j'ai collé un support de batterie 18650 sur la carte, soudé les deux fils sur les bornes prévues :


Ce n'est pas très esthétique ni très pratique. Il serait plus intéressant d'utiliser une batterie LIPO et de la raccorder au connecteur JST prévu sous la carte.
La carte peut supporter une batterie LIPO de 40mm x 60mm.

On peut ensuite brancher un câble micro-USB sur la carte pour recharger éventuellement la batterie.

Une fois la batterie chargée, il vaut mieux la retirer avant d'enficher la carte sur la RASPBERRY PI.

Apparemment, il y a un problème de compatibilité avec la PI 3b : le connecteur de batterie vient buter sur le connecteur POE :


On peut soit se passer du POE et couper les pins du connecteur, soit dessouder le connecteur JST de la carte DFRobot et connecter la batterie par soudure, comme vu plus haut.

On peut ensuite brancher les  câbles de la RASPBERRY (Ethernet, USB, écran, alimentation). Une fois la carte démarrée, mettre la batterie en place.

3.2. Test

Il ne reste plus qu'à débrancher l'alimentation de la RASPBERRY PI pour tester. Bonne nouvelle, cela fonctionne.

3.3. Autonomie

Normalement l'autonomie devrait être de 3 heures avec une batterie de 1000mAH et une RASPBERRY PI 1 ou 2, moitié moins avec une RASPBERRY PI 3 ou 4.

3.4. Recharge

On pourrait penser que la batterie va se recharger lorsque l'on rebranche l'alimentation de la RASPBERRY PI. Hélas non.

La recharge de la batterie nécessite le raccordement de la carte à une deuxième alimentation USB. La recharge sera plus ou moins rapide en fonction de la puissance de l'alimentation. Un chargeur de téléphone peut faire l'affaire.

Le courant de charge maximal est de 1.6A.
Le courant de charge d'une batterie LIPO ou LITHIUM-ION ne doit pas dépasser C/2. Si l'on installe une batterie de 1000mAH il serait préférable d'utiliser un chargeur de 500mA maximum.

Si l'on se contente d'un courant de charge plus faible, il est possible de brancher la carte sur un port USB de la RASPBERRY PI à laide d'un simple cordon USB.
Pendant la charge, si l'alimentation de la RASPBERRY PI est coupée, la charge est stoppée. Ils ont pensé à tout.

3.5. État de la batterie

Un bouton permet de visualiser l'état de charge à l'aide 5 LEDs.

La carte est également équipée d'un microcontrôleur qui peut communiquer par I2C avec la RASPBERRY PI. Un petit script PYTHON pourra facilement récupérer l'état de charge de la batterie.

Voir ici : https://wiki.dfrobot.com/Raspberry_Pi_%20UPS_HAT_SKU_DFR0494

Avec une RAPBERRY PI 2 le résultat est immédiatement au rendez-vous :

La détection du module se passe bien :

pi@raspberrypi:~ $ i2cdetect -y 1
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: 10 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- 38 -- -- -- -- -- -- --
40: -- -- -- -- -- 45 -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --                        


L'exécution du script donne le résultat attendu :

pi@raspberrypi:~ $ python ./ups.py
capacity=4196mV
electricity percentage=98.38
pi@raspberrypi:~ $


J'ai l'impression par contre que le support de l'I2C sur RAPBERRY PI 1 laisse à désirer.
Le seul résultat que j'ai obtenu se résume à peu de choses :

pi@raspberrypi:~ $ sudo i2cdetect -y 1
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: 10 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --                        
pi@raspberrypi:~ $ Connection to 192.168.1.16 closed by remote host.
Connection to 192.168.1.16 closed.


Autrement dit la RASPBEERY PI s'éteint après la détection du module UPS.

3.6. Shutdown automatique

Dans un script de surveillance on peut décider de faire un shutdown de la RASPBERRY PI quand la capacité de la batterie chute en dessous d'un certain seuil.

Après un shutdown automatique, lorsque la tension secteur est rétablie la RASPBERRY PI ne redémarre pas automatiquement.
Si l'on dispose d'un bouton POWER sur la RASPBERRY PI le redémarrage sera facile. Sinon pour redémarrer la carte il faudra débrancher les alimentations secteur, retirer la batterie, puis rebrancher le tout.

Voir ici pour ajouter un bouton POWER :
https://riton-duino.blogspot.com/2019/10/raspberry-pi-un-bouton-power-off.html
Paragraphe 4. Le bouton POWER complet.

3.7. Écran natif 7 pouces

Je remarque après coup qu'avec ce module UPS le backlight de l'écran ne s'éteint pas quand la RASPBERRY PI passe en mode veille.
Testé avec une RASPBERRY PI 2.

4. Les alimentations

Avant de conclure il faut aussi parler du bloc secteur qui alimentera la carte DFR0494.

J'avais jusqu'à présent un bloc 5V / 2A :
Goobay 43652 2A

Acheté fin décembre 2015, décédé il y a peu, début mai 2020.

Ce modèle 5V / 3A également, acheté en 2016, a fonctionné quelques mois :
Aukru-bs-530 3A

J'estime qu'une RASPBERRY PI mérite d'être alimentée avec un bloc de meilleure qualité que ces chargeurs bas de gamme. Ceux-ci ne sont pas capables d'assurer une alimentation permanente 24H/24.

J'ai donc commandé une alimentation plus sérieuse :
MeanWell RS-15-5 3A

Pour un montage sur rail DIN j'utilise ceci :
MeanWell HDR-15-5 2.4A

Le prix de le qualité n'est finalement pas si élevé :
  • Goobay 43652 2A : 10€
  • Aukru-bs-530 3A : 13€
  • MeanWell RS-15-5 3A : 8.50€
  • MeanWell HDR-15-5 2.4A : 12€
  • MeanWell HDR-30-5 3A : 15€
Une alimentation MeanWell nécessitera simplement d'ajouter un cordon µUSB que l'on pourra fabriquer en coupant un cordon classique. On dénudera les fils noir et rouge pour pouvoir les serrer dans son bornier à vis.

5. Photo

Voici la photo du montage avec sa batterie LIPO 3000mAH (42mm x 60mm) et le bouton ON / OFF :


6. Conclusion

Le produit est plutôt bien pensé mais pas totalement. Le shutdown automatique est problématique. Ce système convient seulement si l'on vise à conserver le fonctionnement pendant une coupure secteur de quelques heures, sans shutdown automatique.

Un autre regret : le bouton présent sur la carte pourrait aussi servir de bouton POWER.
La version 1.1 du firmware le permet. Voir ici : https://wiki.dfrobot.com/Raspberry_Pi_%20UPS_HAT_SKU_DFR0494

Cette alimentation UPS est en place sur mon serveur DOMOTICZ (RASPBERRY PI 3B) et donne entière satisfaction, sans shutdown automatique.


Cordialement
Henri

7. Mises à jour

08/11/2019 : 3.7. Écran natif 7 pouces
09/11/2019 : 2. PowerBank
09/05/2020 : 4. Les alimentations
04/06/2020 : 5 Photo

vendredi 18 octobre 2019

RASPBERRY PI : un bouton POWER-OFF (et ON)





RASPBERRY PI : un bouton POWER-OFF

(et ON)


La RASPBERRY PI est une carte très populaire depuis pas mal d'années et permet entre autres de monter à peu de frais un petit serveur domotique. Petit ne veut pas dire peu puissant, bien au contraire.

Un des inconvénients de cette carte, contrairement à d'autres, est qu'elle  ne possède pas de bouton POWER. Cela peut être assez gênant dans le cas où l'on veut pouvoir couper l'alimentation de la carte, car il peut arriver que l'on détériore le système de fichiers de la µSD si l'on coupe son alimentation sauvagement, lors d'un accès en écriture notamment.

Si un écran et une souris sont branchés en permanence sur la RASPBERRY PI (ou un écran tactile) c'est facile de faire un shutdown propre, mais en l'absence d'écran c'est plus compliqué.

Au paragraphe 4 est décrite une solution permettant aussi le démarrage de la carte par le même bouton. Je vous conseille néanmoins de tout lire.

1. Le bouton-poussoir

Nous allons remédier à cela en installant un bouton-poussoir.


J'ai choisi d'utiliser un bouton directement enfiché sur les pins 37 (GPIO26) et 39 (GND) du connecteur 40 points, à l'aide d'un connecteur DUPONT deux broches :

Il faut utiliser le contact NO (Normalement Ouvert) s'il s'agit d'un bouton-poussoir inverseur.
On peut très bien installer ce bouton-poussoir où l'on veut y compris en utilisant deux fils rallonge.

2. La LED


On peut compléter le dispositif avec une LED connectée entre les pins 8 (TX) et 6 (GND). La résistance en série avec la broche + de LED fait 10KΩ.

Cette LED s'éteindra lorsque le shutdown sera terminé.

3. Le logiciel

Pour la partie matérielle c'est terminé. Voyons la partie software.

Nous allons commencer par copier ce script PYTHON (pishdn.py) dans votre répertoire /home/pi :

#!/usr/bin/env python
import RPi.GPIO as GPIO
import os

gpio_pin_number=26

GPIO.setmode(GPIO.BCM)

GPIO.setup(gpio_pin_number, GPIO.IN, pull_up_down=GPIO.PUD_UP)

try:
    GPIO.wait_for_edge(gpio_pin_number, GPIO.FALLING)
    os.system("sudo shutdown -h now")
except:
    pass

GPIO.cleanup()


Ce script attend simplement un passage à l'état ZÉRO de la GPIO26.
Respectez bien l'indentation du code.

On peut rendre ce script exécutable :

chmod 755 pishdn.py

Et on peut l'essayer directement en entrant la commande dans un terminal :

./pishdn.py

Si le bouton est en place, appuyer dessus.

Si l'on a un un écran branché sur la carte, on verra simplement le bureau disparaître, et la LED verte clignoter un certain temps. Au bout d'une dizaine de secondes (sur une RASPBERRY PI 1B) on verra le message "PLYMOUTH POWEROFF SERVICE" apparaître. il faut encore attendre 5 secondes pour que la LED verte s'éteigne définitivement.
Sur d'autres cartes plus récentes, ce sera plus rapide.

Si l'on accède à la carte à travers une connexion ssh, on verra simplement la connexion se fermer :

pi@raspberrypi:~ $ Connection to 192.168.1.16 closed by remote host.
Connection to 192.168.1.16 closed.


Lorsque la LED verte est éteinte, on peut couper l'alimentation sans danger.

Il va falloir maintenant lancer ce script automatiquement au démarrage. Il faut pour cela modifier le script /etc/rc.local à l'aide d'un éditeur (vi, nano ou autre). On va simplement ajouter une ligne (en gras) avant la ligne "exit 0" :

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

# Print the IP address
_IP=$(hostname -I) || true
if [ "$_IP" ]; then
  printf "My IP address is %s\n" "$_IP"
fi

python /home/pi/pishdn.py

exit 0


Il faut maintenant redémarrer :

sudo reboot

On peut vérifier que le script est bien lancé :

pi@raspberrypi:~ $ ps -ef |grep pishdn
root       341   338  0 10:32 ?        00:00:00 python /home/pi/pishdn.py
pi         674   635  0 10:39 pts/0    00:00:00 grep --color=auto pishdn


Voilà c'est tout !

D'autres préfèreront développer un petit service WEB pour pouvoir éteindre leur RASPBERRY PI à l'aide de leur smartphone. Cela sera certainement le sujet d'un futur article.

4. Le bouton POWER complet

Il est possible aussi de démarrer la RASPBERRY PI avec un bouton entre GPIO3 et GND.

Lisez bien ce que l'auteur écrit à propos de la RASPBERRY PI 4.

Un petit schéma :


Nous allons donc être capable de faire le shutdown et le démarrage avec le même bouton mais placé ailleurs, ce qui me donne l'occasion de concevoir une version un peu plus compacte :


Le montage utilise un connecteur 4 broches sur lequel est soudé un petit morceau de plaquette à pastille regroupant la LED et le bouton-poussoir :
  • bouton câblé entre les pins 5 et 6 (GPIO3 and GND)
  • LED + résistance 10KΩ en série câblées entre les pins 8 et 6 (TX et GND)
Le câblage est réalisé avec du fil à wrapper.

Ce montage rend la GPIO4 inaccessible. Est-ce bien grave ?
Si nécessaire il est possible de déporter la carte avec des fils DUPONT.

Pour que le shutdown soit pris en compte il suffit de changer le N° de gpio dans le script pishdn.py (3 au lieu de 26) :

gpio_pin_number=3

Une dernière chose : la batterie que l'on voir derrière le montage est collée sur une carte UPS DFRobot DFR0494.
Voir ici : https://riton-duino.blogspot.com/2019/10/raspberry-pi-ups-dfrobot-dfr0494.html


Cordialement
Henri

4. Mises à jour

20/10/2019 : 2. La LED
24/10/2019 : 4. Le bouton POWER complet