Dimanche, septembre 30 2018

WebRadioRéveilWifi -7-

Suite de l'étude précédente :

On a vu comment intégrer l'électronique de l'horloge, et on va regarder comment intégrer tout le reste, cependant il manque la partie pilotage du Raspberry pour les commandes de la WebRadio.
Et puis quelques trucs que j'ai ajouté par la suite, comme un bouton power off et l'interfaçage avec l'arduino. J'avais fait ça sur le tas, avec des plaquettes à trous, et des bouts de schéma épars…

Je me suis donc efforcé de mettre tout cela au propre sur Kicad.

La carte interface :

  • Le Schéma structurel de la carte interface :

interfaceStructurel.png
On retrouve donc les 3 boutons utiles pour la WebRadio (Playlist1/Playlist2/Stop, Station précédente, Station suivante), un Relai pour déclencher la mise sous tension de l'ampli audio, et un autre pour allumer l'écranLCD.
Les deux relais sont pilotés par le Rpi, et celui de l'ampli est aussi piloté par l'horloge, pour permettre à l'alarme de retentir.
L'horloge est aussi reliée au Rpi pour le déclenchement de la WebRadio.

  • Le circuit de la carte interface :

interface.png
interfaceDessousCuivre.png interfaceDessusCuivre.png interfaceSerigraphie.png

  • Liste des composants:
Nom                 Type et valeur

R1 à R12            Résistances  10kΩ
C1 à C7             Condensateur 100nF
Q1, Q3, Q4          Transistor 2N2222
Q2                  Transistor BS170 ou BS138
K1 et K2            Relais D31C2100
J1 à J15            Pin Header

Voilà donc cette unique carte (avec sa petit séquelle pour le bouton power off) contient la même chose que sur les 3 cartes à trous suivantes.

  • Voici la première, qui concerne les boutons le la WebRadio :

Vous apprécierez le recyclage d'une nappe de disque dur IDE pour la connexion au Rpi.
dsc03532.jpg dsc03530.jpg

  • La deuxième, pour l'interfaçage Rpi <-> Arduino, et le pilotage via relais :

dsc03547.jpg dsc03548.jpg

  • Et la dernière, pour le bouton power off :

dsc03540.jpg dsc03541.jpg

Intégration du Raspberry Pi :

Revenons donc à l'assemblage du WebRadioReveilWifi.
On viens de le voir sur les clichés précédent, il faut fixer le Raspberry avec des vis sur la façade arrière du boitier, et le bouton power off également.

  • Avec de courtes vis de 3 mm de diamètre, et parfois des rondelles pour régler la profondeur de débattement des boutons, si nécessaire.

Intégration des boutons de commande de l'horloge :

dsc03485.jpg

  • Après avoir glissé les boutons imprimés en vert dans leur logement, il suffit de disposer le circuit, les rondelles et de visser ce montage sur le boîtier.

dsc03484.jpg dsc03486.jpg

Intégration des boutons de commande de la WebRadio :

  • Même travail pour visser la plaque à trou. C'est donc ici que j'aurais placé la carte développée en début de ce billet, si je l'avais réalisée au propre.

dsc03546.jpg dsc03534.jpg dsc03535.jpg dsc03536.jpg

Intégration de l'ampli audio :

  • Sur le prototype de la carte ampli audio il n'y avait pas de mélangeur audio, j'ai donc dû le rajouter avec une plaquette à trou, reliée avec les fils jaunes.

Le schéma et le typon de la carte de l'ampli présenté dans les billets précédents intègrent déjà le mélangeur.
dsc03544.jpg dsc03545.jpg

dsc03556.jpgLa carte de l'horloge a été remise en place, ainsi que les haut-parleurs. On pouvait donc placer la carte de l'ampli… Le dessous de la plaquette du mélangeur est isolé avec le la colle chaude, ensuite simplement collé sur l'ampli.

dsc03552.jpg dsc03553.jpg

dsc03542.jpg

Sur la face arrière il y a les fentes permettant d'accéder au potentiomètre Volume et Bass, le trou pour la led power et un jack de sortie femelle 3,5 mm a été fixé. Utile si on veut utiliser un casque.



Intégration de l'écran LCD :

L'écran LCD est un appareil qui à la base sert de retour vidéo de radar de recul pour véhicule. Je l'avais pris à l'époque, ça n'était pas cher, autour de 15€, cependant depuis on fait mieux pour autant, et surtout de meilleure qualité. La résolution max de l'écran est de 640x480, pour une piètre qualité d'image, mais reste suffisant pour être utilisé avec Kodi pour le peu qu'on règle correctement l'affichage. Reportez-vous au billet N°5.
Il se connecte simplement sur la prise RCA Jaune, en vidéo composite donc, et s'alimente en 12V… Et c'est là qu'est le hic !
J'ai tenté d'utiliser des convertisseurs DC/DC boost pour alimenter l'écran en élevant ainsi la tension de 5V à 12V, mais bien que cela fonctionne, l'utilisation avec le pilotage de l'alimentation via le relai posait problème. L'appel d'énergie au moment de la commutation était tel que le Rpi se voyait rebooté; Et l'ajout de condensateurs n'arrangeait malheureusement pas les choses.
dsc03537.jpg J'ai donc dû me résoudre à modifier l'écran, car j'avais eu l'info comme quoi il était possible d'alimenter ce type d'écran en 5V, moyennant bidouille.

  • La difficulté étant que les modèles de circuits de ces écrans là sont assez variés, les informations qu'on trouve se devaient d'être les plus précises possible… et en recoupant plusieurs (maigres) sources, j'ai donc synthétisé la bidouille comme ceci :

dsc03682.jpg dsc03680.jpg
Il fallait donc retirer la diode D4, les selfs L13 et L14, raccorder avec un bout de fil la diode D3 et le CI U2. Alors on peut injecter 5V au lieu de 12V sur le fil rouge pour voir l'écran s'allumer.
Ainsi modifié, le pilotage ON/OFF de l'écran via le relai est tout à fait fonctionnel

  • Le câble alim/vidéo étant passé par le trou prévu dans le boîtier, l'écran est vissé sur la plaquette de la charnière imprimée.

dsc03562.jpgEnsuite on assemble la charnière avec la tige d'un trombone qu'il suffit de glisser dans le trou qu'on aura agrandi avec un foret de 1 mm, et nous voilà avec un écran escamotable.
dsc03563.jpg dsc03564.jpg

Avant de refermer le boitier :

Ça y est, tout est en place, il reste à loger tout ça tranquillement…
dsc03560.jpg

  • Isoler la carte à trou d'interface dans un sac plastique, loger les nappes et câbles de connecteurs.

dsc03557.jpg dsc03558.jpg

Voici ce que ça donne en face arrière.
dsc03590.jpg dsc03589.jpg

Dernières modifs :

En façade avant il restait le trou laissé par la trappe de maintenance pour l'accès à l'arduino, sur le dessus, dans la même idée, le trou permettant de brancher un écran via HDMI, et l'écranLCD ne tiens pas debout tout seul une fois déployé.
J'ai donc modélisé/imprimé quelques pièces supplémentaires :

  • Le cache pour la trappe de façade.

Avec un trou pour y coller le capteur de lumière (ajustement éclairage des afficheurs de l'horloge) et un autre pour coller le capteur infrarouge (télécommande Kodi) dsc03661.jpg dsc03686.jpg

  • Un pied escamotable pour maintenir l'écran à la verticale.

dsc03684.jpg dsc03685.jpg

  • Un cache pour le port HDMI.

dsc03687.jpg dsc03683.jpg

Terminé !

La prochaine fois je ferais une vidéo de démonstration.
dsc03705.jpg dsc03702.jpg
dsc03700.jpg dsc03699.jpg

  • Voilà, donc cette machine fonctionne depuis un an à mon chevet, sans problème majeur autre qu'une corruption de carte SD ayant entrainé le plantage du Rpi.

Pas de réveil par la radio donc, mais j'ai quand même été réveillé par l'horloge et son alarme, étant donné qu'elle s'adresse aussi directement à l'ampli audio.
Les quelques moments où la connexion internet a été perdue, la playlist de secours en fichiers mp3 s'est déclenchée comme prévu !

  • L'appareil consomme assez peu d'énergie, entre 360 mA et 1,3 A, voici plus en détail ce que j'ai mesuré :

- Horloge : luminosité à fond (PWM 255) = 0,200 A
- Horloge : luminosité au minimun (PWM 8) = 0,028 A
- Horloge + Rpi (wifi) au repos : luminosité à fond = 0,527 A
- Horloge + Rpi (wifi) + radio avec ampli (volume au 1/4) : luminosité à fond = 0,600 A
- Horloge + Rpi (wifi) + radio avec ampli (volume au max) : luminosité à fond = 0,750 A
- Horloge + Rpi (wifi) + Kodiavec écranLCD + ampli au repos : luminosité à fond = 1,25 A
- Horloge + Rpi (wifi) + Kodi avec écranLCD + ampli : luminosité à fond = 1,3 A

À suivre…

Samedi, septembre 29 2018

Une éolienne à axe vertical -11-

Suite de l'ouvrage précédent :

  • Le plot en béton a donc eu tranquillement le temps de sécher, le socle a été vissé sur place, et était donc prêt pour y glisser la potence :

Elle sera par la suite sécurisée par un boulon afin de solidariser ces deux pièces, et aussi 3 câbles métalliques tendu, ancrés au sol.
dsc03900.jpg dsc03903.jpg

  • J'ai modélisé et imprimé un cône sur mesure pour coiffer le poteau afin d'éviter que l'eau de pluie n'y ruisselle :

dsc03905.jpg dsc03907.jpg dsc03909.jpg dsc03911.jpg

  • Après avoir défait le montage provisoire des ailes, il est temps de remonter le tout en utilisant vis, écrous et rondelles afin de tout bien ajuster, pour une rotation. des ailes la plus facile possible.

Mais avant deux trous ont été pratiqués dans la croix d'articulation pour pouvoir y fixer le ressort de maintient ouvert. Pour la même raison, deux trous également dans les ailes.
dsc03912.jpg dsc03913.jpg

  • Une petite vidéo :

Le ressort n'est pas encore dans sa position optimale et les têtes de vis gênes sa course, elles seront coupées. Il faudra prévoir un système pour gérer la tension du ressort, afin de régler la vitesse maximale de rotation de l'éolienne.

À suivre…

Dimanche, septembre 23 2018

Bouton on/off Raspberry Pi, Version µContrôleur

Comme je l'évoquais, je ne compte pas utiliser la version précédente du montage « power on/off » pour mon « Pi Hat », car le relais prendrait trop de place, j'ai donc travaillé sur cette nouvelle version à base d'un microcontrôleur Attiny85.

  • Voici donc le schéma de ce nouveau montage :

RpiOnOffAttiny85.png

  • Fonctionnement :

- Pour mettre en route le Rpi, effectuer une pression sur SW1, la sortie PB0 de l'ATtiny85 est alors mise à l'état bas pour permettre au transistor MOSFET de faire passer le 5V au Rpi.
Ici, comme pour le montage précédent, le signal TXD0 est exploité pour connaître l'état du Rpi au moment où le bouton est pressé (état bas, car Rpi éteint) .
- Pour éteindre le Rpi, presser normalement le bouton SW1, ce qui enverra le signal à la sortie PB1 de passer brièvement à l'état haut, pour déclencher un arrêt propre de GNU/Linux via le GPIO21 du Rpi, grâce au script Python3 ci-dessous.
Le pont diviseur que forment R11 et R12 permet de ne n'envoyer que 3,2V au GPIO, car rappelez-vous bien que le Rpi fonctionne en 3,3V !!
- Une fois arrêté de cette manière, le signal TXD0 passe donc à l'état bas, l'état du GPIO ayant été mémorisé, un délai est octroyé pour couper l'énergie et donc 3 secondes après la dernière activité de la led verte du Rpi, la sortie PB0 passe à l'état haut, le transistor MOSFET ne laisse plus passer le 5V au Rpi.
- Presser le bouton SW1 plus de 3 secondes et le courant sera coupé brutalement, utile en cas de plantage du Rpi
- Ce montage gère le reboot. Par contre si on utilise un sudo poweroff sur le Rpi, le courant ne sera pas coupé automatiquement comme avec le relay du montage précédent. Il faudra alors presser SW1 plus de 3 secondes.

  • Prérequis :
sudo apt-get install python3 RPi.GPIO
  • Écrire le script :
nano /home/pi/SoftOffButton.py

Avec dedans :

import RPi.GPIO as GPIO
import time
import os
import signal

print ("Soft Off Button")

GPIO.setmode(GPIO.BCM)
GPIO.setup(21, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)

def button_pressed(channel):
    print ("Boutton Off pressé")
    os.system("sudo poweroff")

GPIO.add_event_detect(21, GPIO.RISING, callback=button_pressed)

signal.pause()

Pour démarrer automatiquement le programme python dés le démarrage du Raspberry, il faut créer un service :

sudo nano /etc/systemd/system/SoftOffButton.service

Avec dedans :

[Unit]
Description=Démarre le script SoftOffButton
[Service]
ExecStart=/usr/bin/python3 /home/pi/SoftOffButton.py
[Install]
WantedBy=multi-user.target

Installer le service au démarrage :

sudo systemctl --system daemon-reload
sudo systemctl enable SoftOffButton.service

Pour manipuler le service :

sudo systemctl status SoftOffButton.service
sudo systemctl start SoftOffButton.service
  • Quelques composants sont au format CMS pour le montage sur plaquette labo, car ils serviront au « Pi Hat » que je réaliserais.

20180923_215557.jpg
L'ATiny85 et le MOSFET sont câblés sur des pin header avec du fil émaillé RoadRunner super pratique, conseillé par Sacha !

  • Programme ATtiny85 :

Voici le programme à coller dans le µContrôleur, j'ai utilisé la méthode décrite par Héliox pour le programmer via un ArduinoUNO :

#define relaisMOSFET 0  //PB0, pin5
#define Bouton 2        //PB2, pin7
#define TDX0 3          //PB3, pin2
#define BoutonGPIO21 1  //PB1, pin6
#define STATE_NORMAL 0  // no button activity
#define STATE_SHORT 1   // short button press
#define STATE_LONG 2  // long button press
volatile int  resultButton = 0; // global value set by checkButton()
int EtatTXD0;
int EtatBouton;
int var = 0;

void setup() {
  attachInterrupt(0, checkButton, CHANGE);
  pinMode(Bouton, INPUT_PULLUP);
  pinMode(TDX0, INPUT);
  pinMode(BoutonGPIO21, OUTPUT);
  pinMode(relaisMOSFET, OUTPUT);
  digitalWrite(relaisMOSFET, HIGH); // power off
}

/*****************************************************************/
void checkButton() { // appelée par interruption à l'appuie sur le bouton
  /*
  * This function implements a short press and a long press and identifies between
  * the two states. Your sketch can continue processing while the button
  * function is driven by pin changes.
  * https://www.electro-tech-online.com/threads/dual-state-pushbutton-debounced-using-interrupts-for-arduino.147069/
  * Modifié par MakotoWorkshop
  */
  const unsigned long LONG_DELTA = 3000ul;               // hold seconds for a long press
  const unsigned long SHORT_DELTA = 0ul;               // hold seconds for a long press

  static int lastButtonStatus = HIGH;                                   // HIGH indicates the button is NOT pressed
  int buttonStatus;                                                                    // button atate Pressed/LOW; Open/HIGH
  static unsigned long longTime = 0ul, shortTime = 0ul; // future times to determine is button has been poressed a short or long time
  boolean Released = true, Transition = false;                  // various button states
  boolean timeoutShort = false, timeoutLong = false;    // flags for the state of the presses

  buttonStatus = digitalRead(Bouton);                // read the button state on the pin "Bouton"
  timeoutShort = (millis() > shortTime);                          // calculate the current time states for the button presses
  timeoutLong = (millis() > longTime);

  if (buttonStatus != lastButtonStatus) {                          // reset the timeouts if the button state changed
      shortTime = millis() + SHORT_DELTA;
      longTime = millis() + LONG_DELTA;
  }

  Transition = (buttonStatus != lastButtonStatus);        // has the button changed state
  Released = (Transition && (buttonStatus == HIGH)); // for input pullup circuit

  lastButtonStatus = buttonStatus;                                     // save the button status

  if ( ! Transition) {                                                                //without a transition, there's no change in input
  // if there has not been a transition, don't change the previous result
       resultButton =  STATE_NORMAL | resultButton;
       return;
  }

  if (timeoutLong && Released) {                                      // long timeout has occurred and the button was just released
       resultButton = STATE_LONG | resultButton;       // ensure the button result reflects a long press
  } else if (timeoutShort && Released) {                          // short timeout has occurred (and not long timeout) and button was just released
      resultButton = STATE_SHORT | resultButton;     // ensure the button result reflects a short press
  } else {                                                                                  // else there is no change in status, return the normal state
      resultButton = STATE_NORMAL | resultButton; // with no change in status, ensure no change in button status
  }
}
/*****************************************************************/

void loop() {
  SoftPowerONOFF();
  HardPowerOFF();   // Coupe l'alim brutalement
  delay(170);       // wait for a second
}

/*****************************************************************/
void SoftPowerONOFF() {
  EtatTXD0 = digitalRead(TDX0);

  if ((EtatTXD0 == LOW) && (resultButton == STATE_SHORT)) //POWER ON via bouton
  {
    digitalWrite(relaisMOSFET, LOW); // power on
    resultButton=STATE_NORMAL;
  }
  
  else if ((EtatTXD0 == HIGH) && (resultButton == STATE_SHORT)) //SOFT POWER OFF via bouton, étape1/2
  {
    digitalWrite(BoutonGPIO21, HIGH); // 3,2V envoyé au Rpi -> appel du Script Rpi Shutdown
    delay(200);                       
    digitalWrite(BoutonGPIO21, LOW);  // 0V
    var = 1;
    resultButton=STATE_NORMAL;
  }
  
  else if ((EtatTXD0 == LOW) && (var == 1)) //SOFT POWER OFF via bouton, étape2/2
  {
    delay(7000);    // délai pour couper l'énergie, 3 sec après la dernière activité led verte du Rpi
    digitalWrite(relaisMOSFET, HIGH);  //power off
    var = 0;
  } 
}

/*****************************************************************/
void HardPowerOFF() {
  if ((resultButton == STATE_LONG)) // appuie long sur le bouton (3 sec)
  {
    digitalWrite(relaisMOSFET, HIGH);  //power off
    resultButton=STATE_NORMAL;
  }
}

Jeudi, août 23 2018

WebRadioRéveilWifi -6-

Suite de l'étude précédente :

Je me rend compte que j'ai un stock de photo que je conservais pour rédiger un billet, tout en attendant d'avoir terminé de dessiner un schéma à y intégrer, mais en fait y'a suffisamment de photos pour déjà montrer un billet intermédiaire… Allons-y !

Avant de parler informatique et script Python, nous en étions donc resté à la partie électronique concernant l'horloge à base Arduino et l'ampli audio à base LM386.

  • Il est donc temps de passer à la réalisation du boîtier. Pour ce faire j'ai utilisé l'outil qui me semblait le plus adéquat pour ce genre de design, et c'est donc avec Sketchup que j'ai modélisé mon WebRadioRéveil.

Parce que les cartes électroniques étaient terminées, les haut-parleurs choisi et le Raspberry sous la main, j'ai pu m'appuyer sur leurs dimensions (non sans commettre d'erreurs…) pour construire la 3D du boîtier autour.
Ensuite il fallait procéder à sa découpe en morceaux pouvant être imprimés sur mon plateau de 19x19 cm, et donc imaginer un système d'assemblage pas trop foireux…

  • Le design est disponible et consultable sur la page Thingiverse et en annexe à ce billet.

Impression des pièces :

  • Une petite vidéo, une des pièces à destination d'un haut-parleur :

Qui viennent de part et d'autre de la partie centrale avec le plastique fumé pour l'horloge : dsc03460.jpg dsc03459.jpg

  • Le dessus et le dessous (qui comporte une rainure pour caler la carte de l'horloge, que j'ai dû pratiquer suite à une erreur de mesure).

dsc03457.jpg dsc03455.jpg

  • Les côtés et le fond.

dsc03453.jpg dsc03452.jpg

Assemblage à blanc:

  • Avec de l'adhésif de peintre, en ayant intégré l'horloge :

dsc03451.jpg
dsc03446.jpg dsc03447.jpg dsc03450.jpg dsc03449.jpg
dsc03445.jpg dsc03448.jpg

Collage :

  • Bon ça se tiens, c'est cohérent, et fonctionnel, on va pouvoir précéder au collage.

D'abord les demi-panneaux ensembles, collés à la cyanoacrylate…
dsc03461.jpg dsc03462.jpg dsc03466.jpg dsc03464.jpg

  • Le ruban adhésif est utilisé pour bien centrer et caler bord à bord les pièces qui vont être assemblées avec un joint de colle par repliage.

dsc03468.jpg dsc03467.jpg
dsc03469.jpg

Les jointures n'étant pas toutes très esthétiques, en tant que maquettiste, je me suis dit qu'il faudrait mastiquer et poncer pour améliorer le rendu !
Sauf qu'ensuite il serait obligatoire de peindre pour cacher le mastique, ce qui n'était pas prévu… Hum comment faire ?
Bon apparemment la technique est connue, même si j'ai aussi eu l'idée sans la chercher sul'ternet !!

  • Simplement, fabriquer du mastique avec des chutes de plastique, (des petits morceaux de ratés d'impression et des supports, tout ça quoi…) à faire fondre dans le l'acétone. Ensuite il reste à badigeonner ça sur les jointures, et attendre que ça durcisse correctement.

dsc03470.jpg dsc03471.jpg

  • Ensuite faut limer et poncer donc, et le résultat est là !

dsc03472.jpg dsc03474.jpg

  • C'est terminé pour la partie principale du boîtier, le dessous et le fond étant amovibles pour permettre l'intégration de l'électronique, qu'on verra la prochaine fois :)

dsc03475.jpg dsc03476.jpg dsc03478.jpg dsc03479.jpg dsc03482.jpg

À suivre…

Mardi, août 21 2018

Plaquette Rpi RPIO

  • J'utilisais jusqu’à présent la petite plaquette aide mémoire bien pratique « Raspin’s » du camarade idleman et depuis le passage au Rpi2 puis 3 puis Zero, l'équivalent pour le modèle 40 pins me manque beaucoup.

Alors j'ai vu qu'il en existait deux ou trois modèles, et même des trucs en dur type plaquette epoxy comme chez adafruit, mais je ne les trouvais pas à mon goût, soit il manquait des indications, soit c’était pas très clair, soit le look ne me plaisait pas…

  • Devinez quoi… Bah j'en ai fait une, avec quelques indications supplémentaires récoltées sur le site de la fondation, voilà :

Rpi_GPIO_Makoto1.png
Pour la concevoir, j'ai utilisé un tableur, (Libre Office Calc) puis suis passé sur Gimp pour quelques retouches.

  • Fichiers sources en pièces jointes à ce billet, dont une page A4 pour imprimer 8 plaquettes d'un coup.

Je conseille soit d'imprimer sur du papier épais, soit d'y coller une seconde feuille après impression.
Je ne suis pas infaillible, et vous n'êtes pas dispensé de vérifier qu'une coquille ne soit présente dans ce document, auquel cas vous pourriez bien pleurer en cas d'avarie sur votre Rpi…

20180821_193015.jpg
Précision, la distance entre le centre de la pin 1 et 39 (sur la page A4, entre les traits roses) doit faire 48,2 mm.

Samedi, août 18 2018

Un bouton power on/off pour le Raspberry Pi

Je suis en train de travailler à l’élaboration d'une carte de type « Pi Hat », équivalent du « Schield » pour Arduino, à savoir une carte qu'on enfiche par dessus le Raspberry.
Cette carte destinée au Rpi Zero, comportera une sortie Audio avec son amplificateur, deux connecteurs FCP pour connecter un écran LCD de type SPI - ILI9341, un connecteur pour déporter des GPIO sur une nappe de fil, et enfin un connecteur d'alimentation 5V avec un système de bouton On/Off sécurisé.
Tout ceci dans le but d’intégrer un montage dans une maquette…

Après beaucoup de temps perdu à tenter de comprendre ce dessin, en vue de bien sûr tester le concept, j'ai dû me résoudre à le redessiner complètement, en respectant les normes de représentation. Le voici : ( ouf ! )
RpiOnOffRelay.png

  • Fonctionnement :

- Pour mettre en route le Rpi, effectuer une pression longue sur le bouton SW1, afin de laisser le temps au signal TXD0 de passer à l'état haut et de faire coller le relais qui maintiens alors le Rpi alimenté en énergie.
- Pour éteindre le Rpi, le bouton SW1 étant connecté sur une sortie GPIO, il suffit de le presser normalement pour déclencher un arrêt propre de GNU/Linux grace au script Python3 ci-dessous.
- Une fois arrêté, le signal TXD0 passe donc à l'état bas et le relais se décolle alors, coupant l'énergie du Rpi.
- Le bouton SW2 sert à couper brutalement le courant, en cas de plantage du Rpi
- Ce montage ne gère pas le reboot. Effectuer un redémarrage éteindra donc le Raspberry, car durant le redémarrage TXD0 passe à l'état bas…
Édit : Passer C2 à 220µF et le relais attendra 5 secondes avant de couper , ça devrait permettre un reboot sans coupure.

  • Prérequis :
sudo apt-get install python3 RPi.GPIO
  • Écrire le script :
nano /home/pi/SoftOffButton.py

Avec dedans :

import RPi.GPIO as GPIO
import time
import os
import signal

print ("Soft Off Button")

GPIO.setmode(GPIO.BCM)
GPIO.setup(21, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)

def button_pressed(channel):
    print ("Boutton Off pressé")
    os.system("sudo shutdown now")

GPIO.add_event_detect(21, GPIO.RISING, callback=button_pressed, bouncetime=300)

signal.pause()

Pour démarrer automatiquement le programme python dés le démarrage du Raspberry, il faut créer un service :

sudo nano /etc/systemd/system/SoftOffButton.service

Avec dedans :

[Unit]
Description=Démarre le script SoftOffButton
[Service]
ExecStart=/usr/bin/python3 /home/pi/SoftOffButton.py
[Install]
WantedBy=multi-user.target

Installer le service au démarrage :

sudo systemctl --system daemon-reload
sudo systemctl enable SoftOffButton.service

Pour manipuler le service :

sudo systemctl status SoftOffButton.service
sudo systemctl start SoftOffButton.service

20180818_141218.jpg

  • Ce montage fonctionne très bien, et vu le temps passé dessus j'ai voulu le partager à ceux qui pourraient en avoir besoin.

Je ne compte pas l'utiliser pour mon « Pi Hat », car le relais prendrait trop de place, et j'envisage une solution plus souple et élégante à base de microcontrôleur.

Dimanche, août 12 2018

SmartrapCore, imprimante 3D -5-

Suite de l'étude précédente :

  • En attendant le prochain billet à propos de quelques évolutions et des réglages logiciels de l'imprimante, voici une petite vidéo sur mes remarques concernant la tête d'impression E3DV6. Démontage et analyse du sujet :

À suivre…

Samedi, juillet 21 2018

Fabrication rapide d’un clip de montage pour garde boue

Je voulais pouvoir monter et démonter rapidement les gardes boue de mon vélo. Le problème c’est qu’à l’arrière il faut démonter la roue pour le fixer. Hors de question!

Je modélise un petit support en plastique qui sera vissé sur le garde boue. Le support vient se clipser sur le cadre sans avoir à retirer la roue. Mission accomplie </div>
            
            
                          <p class= aucun rétrolien

- page 1 de 98