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

Jeudi, juin 7 2018

Une éolienne à axe vertical -10-

Suite de l'ouvrage précédent :

J'avais donc préparé toutes les pièces de la potence, qui n'attendaient plus qu'à être assemblées.

  • Revoici le système d'attache des roulements, ici mis en situation pour bien positionner les petites équerres :

dsc03802.jpg dsc03801.jpg dsc03799.jpg dsc03800.jpg

  • La première est soudée en place, et comparé à toutes mes soudures précédentes, c'est plutôt pas mal ^^ !

dsc03803.jpg dsc03806.jpg

Certes elles ne sont pas très jolies, mais c'est surtout que je les ai réussi du premier coup ! Que de temps gagné !
dsc03804.jpg dsc03807.jpg

Je dois ce progrès fulgurant à un vidéaste qui a su condenser en 10 min l'essentiel du bon geste du soudeur, grand merci à lui !

J'avais beau constater mes défauts, voir ce qui n'allait pas, comprendre que mon geste n'était pas le bon, et savoir théoriquement ce qu'il fallait faire pour y remédier, rien à faire… Et puis, je trouve cette vidéo en cherchant à en savoir plus sur la soudure TIG et MIG/MAG, et là, pouf, je visualise directement la clef ! J'ai eu le sentiment que j'y arriverais, et c'est ce qu'il s'est produit ^^

  • L'équerre qui viens bloquer le roulement en place est fixée avec des boulons, après perçage bien-évidemment.

dsc03810.jpg dsc03811.jpg

  • Ensuite on à fait des trous pour fixer le U contre le mât, ainsi que les barres de volets à 45°.

dsc03817.jpg dsc03818.jpg dsc03819.jpg dsc03821.jpg

IMG_0239.jpg

  • À ce moment de la construction (Oui y'a un accent sur le A t'as vu ? C'est que j'utilise un vrai clavier d'ordinateur en Français ^^), on a voulu vérifier que tout allait bien avec une petite mise en situation de la potence du haut.

Et bah ça marche ^^
Le mât et ses barres à 45° ne viennent pas gêner la voilure déployée…

  • Le haut du mât sera stabilisé avec 3 câbles depuis le sol, j'entrepris alors de souder des maillons de chaîne pour y ancrer ces câbles… Avec un plaisir renouvelé par un soudage rapide, correct et fiable. J'ai meulé les soudures pour m'assurer de leur qualité mécanique effective…

dsc03822.jpg dsc03823.jpg

  • Ensuite nous avons fixé le bras de potence du bas, et entrepris de rallonger le mât, car malheureusement soit il avait été débité en morceaux, soit c'était des morceaux épars trouvé tel quel lors de la phase de récupération… bref, soudure ^^

dsc03868.jpg dsc03869.jpg

dsc03878.jpg

  • Voilà, terminé !

dsc03872.jpg dsc03875.jpg dsc03873.jpg dsc03874.jpg dsc03876.jpg

  • Direction le fond du jardin pour bâtir le plot en béton qui accueillera le support du mât (cf, épisode 3).

p5250534.jpg p5250001.jpg

À suivre…

Lundi, juin 4 2018

Horloge de salon

Je ne sais plus si je l'ai évoqué ici, mais j'avais envie d'une horloge avec ces afficheurs bleu qui me plaisaient bien, repérés lors des essais sur le projet WebRadioReveilWifi, et j'avais donc procédé au tirage d'une seconde carte imprimée dans ce but.

  • Le circuit est donc identique, à ceci prés que la valeur des résistances associées aux afficheurs est ajustée à 100Ω, qu'un buzzer remplace l'ampli et son haut-parleur, et que cette fois est utilisé le capteur de mouvement PIR.
  • Voici la carte et ses périphériques, une fois le tout percés/soudés : Une plaquette translucide fumée, un Arduino mini 5V, les modules RTC et PIR, le buzzer, la plaquette des boutons de commande et sa nappe associée, et enfin un connecteur jack pour l'alimentation.

dsc03602.jpg dsc03601.jpg

  • En fonctionnement, sur dix dix, évidemment ! (comprenne qui pourra ^^)

Les leds des alarmes sont cette fois soudées à l'arrière, pour un usage très occasionnel.
dsc03596.jpg dsc03614.jpg

Un boîtier ?

Même si le réflexe impression 3D commence à devenir naturel, je n'ai pas perdu mon habitude à conserver tout un tas de merdier pour ce genre d'occasion, et c'est ici un vieux boîtier externe de disque dur qui va servir… il était temps, j'ai failli me décider à le jeter… Où alors c'est justement pour ça que je me suis souvenu de lui… bref  !

  • Le logo, j'en veux pas, une partie sera coupée par l'emplacement des afficheurs, mais en plus il est en creux et la surface du boîtier texturée… hum que faire ?

dsc03594.jpg dsc03595.jpg

  • Et bah, tout poncer !!

Bon j'y suis allé un peu trop fort, et j'ai eu plus de travail que prévu pour rattraper le coup, avec un petit polish au dentifrice.
dsc03605.jpg dsc03606.jpg

Le plus difficile lorsqu'on intègre une carte dans un boîtier, c'est de disposer le tout le plus précisément possible alors qu'on-y voit rien, le boîtier n'est pas transparent, ça aide pô…

  • Alors on y passe du temps, et on fini par y arriver, ici avec les vis de support dans la face arrière du boîtier afin de fixer la carte, pouvoir régler sa hauteur et donc l'affleurement des afficheurs.

Puis les trous des Leds d'alarmes et celui pour sortir le son du buzzer.
dsc03609.jpg dsc03613.jpg

  • Technique du gabarit de perçage pour disposer les trous le plus correctement possible.

dsc03612.jpg dsc03616.jpg

  • Des boutons imprimés 3D verts sont en places, avec les vis de support pour accueillir la plaquette de commande. Idem ici, on peut régler la hauteur de la plaquette pour ajuster la course des boutons.

La plaquette fumée est collée à la cyano, tandis que le connecteur jack est collé sur le côté, à l'endroit originel du jack de ce boîtier à disque dur.
dsc03615.jpg dsc03617.jpg

  • Un trou pour le capteur PIR et un autre pour la photorésistance, qui sont alors collés à l'aide de colle chaude :

dsc03618.jpg dsc03619.jpg dsc03678.jpg dsc03677.jpg

  • Le buzzer est lui aussi collé en face de son trou sur la face arrière.

dsc03675.jpg dsc03674.jpg

  • Yapuka refermer !

dsc03671.jpg dsc03657.jpg

Biennnn !

Bon alors pour résumer, l'horloge fonctionne tout à fait pareil que le WebRadioReveilWifi pour ce qui est de la mise à l'heure et du réglage des alarmes.

Les sonneries sont identiques aussi, quelques morceaux la chiptune aléatoires.
Lorsque l'ambiance lumineuse de la pièce s'assombrit, la luminosité des afficheurs baisse, grâce à la photorésistance.
Et enfin les afficheurs s'éteignent tout seul au bout de 3h environ, ce n'est que lorsqu'un mouvement est détecté par le capteur PIR que l'affichage se remet en marche !!

Le code est cependant un poil différent pour prendre en charge ce capteur. Dispo en annexe du billet.
dsc03658.jpg dsc03662.jpg dsc03663.jpg dsc03664.jpg dsc03666.jpg dsc03667.jpg dsc03668.jpg

- page 1 de 98