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

  • L'appareil consomme assez peu d'énergie, entre 25 mA et 146 mA, et quasi rien lorsque l'affichage est éteint :

- Horloge : luminosité à fond (PWM 128) = 0,146A
- Horloge : luminosité au minimun (PWM 5) = 0,025 A

Jeudi, mai 31 2018

Un pegboard pour mes outils -1-

  • Le pegboard, ou panneau à trous pour accrocher des trucs, c'est comme son nom l'indique un panneau avec des trous pour y enficher des crochets et y suspendre des trucs…

Taper ce mot clef sur l'ternet, et vous découvrirez pléthore de « trucs déco » relativement inutiles, pendant que je redécouvrais le concept au détour d'une recherche d'objet3D sur Thingiverse, alors que je connaissais la version planche à clous de l'atelier du père qui ne m'a jamais vraiment convaincu.

  • Alors ici on va mixer les 3 :

- Un truc pas trop moche, sans appeler ça déco…
- Un truc fiable et plus efficace que des clous en guise de crochet.
- Un truc à base de crochets imprimés3D sur mesures.

Parce que oui, j'en ai marre de voir traîner mes outils d'usage courant traîner et encombrer mon plan de travail… Objectif, tout suspendre !

  • On peut trouver au brico, autour de 10€, une simple plaque d'isorel percée… Bon j'aurais pu acheter ça, mais d'un j'ai trouvé ça cher, et deux elle était trop petite.

Alors j'ai pris une grande plaque d'isorel pour 3€ , et j'ai fait des p'tis trous, des p'tis trous, encore des p'tis trouuuuus… Des trous d'quatre millimèèèètreuuuuu, tous les 25 millimèèèètreuuuu.
Wé, si tu connais pas la chanson bah tant pis…

  • Donc j'ai fait le plus précisément possible un quadrillage de 25 mm et percé des trous de 4 mm de diamètre sur une chute d'isorel, qui m'a servis de gabarit de perçage pour trouer la grande plaque.

dsc03412.jpg dsc03417.jpg dsc03418.jpg dsc03419.jpg

  • En calant le gabarit correctement avec des tiges pour augmenter la précision.

dsc03420.jpg dsc03421.jpg

  • Ensuite pour quelques sous de plus, découpage - collage - clouage de petits tasseaux de 9 x 13 mm pour encadrer le panneau.

dsc03422.jpg dsc03426.jpg

  • Voilà, terminé ?

dsc03427.jpg dsc03429.jpg
dsc03430.jpg

  • Non, j'ai limé les clous qui dépassaient un peu de l'autre côté, histoire de pas abîmer le mur, et hop, 4 chevilles molly et c'est mis en place !




dsc03434.jpg dsc03435.jpg

  • Maintenant on colle du papier peint pour mieux intégrer le pegboard au mur… Hé oui, faut jamais jeter le dernier rouleau de papier entamé !

dsc03436.jpg dsc03437.jpg dsc03438.jpg dsc03440.jpg

  • Bon les photos ne sont pas terribles, car prise en lumière hivernale, et je communiquerais plus tard sur l'avancement de l'affaire, car je modélise et imprime mes crochets au fur et à mesure, que je partagerais alors ici et sur ma page Thingiverses.

Bien-évidemment je perce les trous dans le papier au besoin…
Pour le moment, à part mon crochet de base décliné en différentes tailles, j'ai fait notamment un support pour le pied à coulisse, outil ô combien utile, le support pour mon ordiphone, un support de webcam ainsi que pour la lampe qui me servent à streamer des trucs sur ma page twitch.
dsc03718.jpg dsc03711.jpg
dsc03712.jpg dsc03713.jpg
dsc03714.jpg dsc03715.jpg

À suivre !!

Vendredi, mars 30 2018

Assurance temporaire auto : Pas cher et en ligne !

L’assurance temporaire auto s’adresse aux conducteurs recherchant une couverture dont la durée de validité reste précise et courte et offrant les garanties minimales en termes de couverture auto. Elle couvre généralement sur une période de 1 à 90 jours et ne peut être souscrite que par un conducteur attestant au moins de 2 ans d’expérience sur la route. Généralement, le souscripteur doit être âgé d’au moins 21 ans. L’assurance temporaire auto offre la possibilité de couvrir les risques pour une durée courte et déterminée. Même si elle offre une couverture limitée comparée à l’assurance classique, ses garanties suffisent largement au vu des circonstances.

Prix de l’assurance temporaire

Les tarifs pratiqués par les assureurs sont libres et diffèrent souvent de par les conditions d’accès et les couvertures de l’assurance temporaire auto. C’est la raison pour laquelle, il est nécessaire de faire un travail préalable de prospection avant de choisir son assureur. Cette initiative assurera du bon choix du prestataire tant au niveau budget qu’au niveau de l’adéquation besoin/offre. Concrètement et à titre d’exemple, une assurance temporaire auto d’une journée coûtera 11€, 7jours coûtera 50€ et 1 mois sera taxé 200€. Ces prix sont approximatifs mais représentent néanmoins une moyenne.

L’assurance temporaire auto est intéressante pour les cas suivant :véhicule peu utilisé ou mobile de manière exceptionnelle et placé dans un local sécurisé et privatif, dans le cadre d’un déplacement à l’étranger pour lequel le contrat d’assurance classique ne couvre pas les risques, dans l’attente d’un nouveau contrat d’assurance auto classique, dans le cadre de l’importation d’un véhicule provenant de l’étranger doté donc d’une immatriculation temporaire et en attendant le certificat d’immatriculation définitif, en cas de suspension ou résiliation d’un contrat d’assurance auto classique et dans l’attente de pouvoir en souscrire un nouveau et dans l’attente de souscription d’un contrat classique pour une quelconque raison.

Samedi, mars 3 2018

WebRadioRéveilWifi -5-

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

L'Horloge/Réveil étant fin prête, il est temps de réviser la configuration de la WebRadio.
J'ai tout repris de zero… C'est qu'il s'est passé pas mal de temps depuis les premières expérimentations, et pas mal de version de Raspbian sont passées sous les ponts !

Pour rappel, j'ai décidé d'articuler la WebRadio autour d'un Raspberry Pi 1 (où Rpi zeroW car le 1 n'est plus en vente), de quelques boutons d'interactions, d'une cellule infrarouge et d'un écran LCD (facultatif) bon marché type radar de recul.

  • On va ici étudier la partie software, la partie hardware concernant le câblage des GPIO, relais et interfaçage horloge, pilotée par le programme mpc.py venant au prochain billet.

1 - Installer et configurer Raspbian Lite :

  • Déployer l'image sur une carte SD depuis un système GNU/Linux, avec la commande DD

(attention, of=/dev/sdx à adapter pour la cible de votre carte SD, en cas d'erreur risque d'effacement d'un disque dur non désiré)

dd bs=4M if=2017-11-29-raspbian-stretch-lite.img of=/dev/sdx; sync
  • Placer la carte SD dans le Raspberry, et le mettre sous tension.

Exécuter raspi-config, et configurer tous les trucs comme on veut, notamment les variables locales (time zone, clavier, etc), et surtout le login automatique de l'utilisateur.

sudo raspi-config

raspi-config01.png
raspi-config02.png
raspi-config03.png

Après le reboot, pour rappel :

Login : pi
Pass : raspberry

  • Effectuer les mises à jour :
sudo apt update
sudo apt upgrade
  • Mettre les fichiers temporaires en ram pour économiser sur la durée de vie la la carte SD.
sudo nano /etc/fstab
tmpfs      /tmp		tmpfs	defaults,size=256M	0    0
tmpfs      /var/tmp	tmpfs	defaults,size=256M	0    0
tmpfs      /var/log	tmpfs	defaults,size=256M	0    0
  • Pour configurer le wifi, éditer le fichier /etc/wpa_supplicant/wpa_supplicant.conf et modifier comme suit la section wlan0 : (ou par raspi-config)
sudo nano /etc/wpa_supplicant/wpa_supplicant.conf
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=FR

network={
        ssid="le nom du réseau wi-fi"
        psk="le mot de passe du réseau wi-fi"
}
  • Relancer ensuite le réseau avec la commande :
sudo service networking restart
  • Pour régler la résolution d'écran afin de l'adapter au petit écran type radar de recul :
sudo nano /boot/config.txt
framebuffer_width=320 
framebuffer_height=240
  • Configurer la sortie sonore sur le jack plutôt que le HDMI (par défaut) :
amixer cset numid=3 1
  • Régler le niveau sonore, puis sauvegarder les modifications :
alsamixer
sudo alsactl store 0



2 - Les logiciels pour la WebRadio :

  • Installer le lecteur de musique, le pilotage GPIO et la synthèse vocale :
sudo apt install mpd mpc wiringpi espeak
  • Configuration du lecteur mpc/mpd, éditer :
sudo nano /etc/mpd.conf

Indiquer les chemins où seront stockés les playlists et les fichiers mp3 :

music_directory         "/home/pi/music"
playlist_directory              "/home/pi/playlists"

Puis relancer le service mpd

sudo service mpd restart
  • Écriture d'une playlist de station de radio :

Créer un fichier portant l’extension .m3u avec simplement la liste des URL des stations radio

nano /home/pi/playlists/radio.m3u
# StahlRadio - Metal - http://stahlradio.de/
http://streamplus52.leonex.de:22810/;
# Radio Metal - http://www.radiometal.com/
http://stream.radiometal.com:8010
# EBM Radio - Industrial, Futurepop, Synthipop, Dark Wave, Gothic, ... et Depeche Mode
http://ebm-radio.org:9000/ebm.ogg
# japanfm
http://radio.japanfm.fr/japan
# TSF Jazz
http://tsfjazz.ice.infomaniak.ch:80/tsfjazz-high
# Radio Neo - Français
http://stream.radioneo.org:8000/;chat.mp3
# Radio Equinoxe - Electo - http://radioequinoxe.com/radio/liens-decoute/
http://www.radioking.com/play/radio-equinoxe/76118
  • Écriture d'une playlist de fichier mp3 :

Créer un fichier portant l’extension .m3u avec simplement la liste des fichiers mp3 (stockés dans le dossier /home/pi/music)

nano /home/pi/playlists/FarCryBloodDragon.m3u
01. Rex Colt.mp3
02. Blood Dragon Theme.mp3
03. HELO-73.mp3
04. Warzone.mp3
05. Moment of Calm.mp3
06. Dr Elizabeth Darling.mp3
07. Power Core.mp3
08. Protektor.mp3
09. Sloan.mp3
10. Sloan's Assault.mp3
11. Blood Scope.mp3
12. Combat I.mp3
13. Combat II.mp3
14. Combat III.mp3
15. Katana.mp3
16. Omega Force.mp3
17. Nest.mp3
18. Rex's Escape.mp3
19. Love Theme.mp3
20. Sleeping Dragon.mp3
  • Et attention, pour que les fichiers mp3 soient pris en compte, il est nécessaire de scanner le dossier « music », sinon les mp3 ne fonctionneront pas !!
mpc update
  • La config est prête, voici le programme python mpc.py qui exploite tout ça pour fournir le service :
#!/usr/bin/env python2.7
# coding: utf-8
# on importe les modules nécessaires

import time
import os, sys
import RPi.GPIO as GPIO
import subprocess
import socket
# on met RPi.GPIO en mode notation BCM (numéro des pins)
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
# on initialise les GPIO en mode "écoute" (GPIO1 sur la nappe)
GPIO.setup(17, GPIO.OUT, initial = GPIO.LOW)        # GPIO0 - pin11 - Relais Ampli
#GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_UP)  # GPIO1 - pin12 - LIRC
GPIO.setup(27, GPIO.IN, pull_up_down=GPIO.PUD_UP)   # GPIO2 - pin13 - Station suivante
GPIO.setup(22, GPIO.IN, pull_up_down=GPIO.PUD_UP)   # GPIO3 - pin15 - PowerOFF
GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP)   # GPIO4 - pin16 - Station précédente
GPIO.setup(24, GPIO.IN, pull_up_down=GPIO.PUD_UP)   # GPIO5 - pin18 - LCD ON/OFF
GPIO.setup(25, GPIO.IN, pull_up_down=GPIO.PUD_UP)   # GPIO6 - pin22 - Play/pause/stop   ne fonctionne plus à cause de la tempo 1H
GPIO.setup(4, GPIO.OUT, initial = GPIO.LOW)     # GPIO7 - pin7  - Relais LCD

long_press = 1
very_long_press = 3
site = 'www.google.fr'

# Nettoyage lecteur média
os.system('mpc clear')

def is_connected(REMOTE_SERVER):
        try:
                # see if we can resolve the host name -- tells us if there is a DNS listening
                host = socket.gethostbyname(REMOTE_SERVER)
                # connect to the host -- tells us if the host is actually reachable
                s = socket.create_connection((host, 80), 2)
                return True
        except:
                pass
                return False

# Chargement de la playlist
if is_connected(site):
#     print "Site disponible"
     os.system('mpc load radio')
else:
#     print "Site indisponible"
     os.system('mpc load foo')

# au bout de QUelques minutes, stopper la lecture
heure=0
fin=9999999999

# fonction qui sera appelée quand on appuiera sur le bouton 25
def bouton25(a):
    global fin
    button_press_timer = 0
    GPIO.remove_event_detect(25) # empéche le bouton d'etre détecté x fois de plus
    while True:
        if(GPIO.input(a) == GPIO.LOW ): # bouton appuyé
            button_press_timer += 0.2 # incrémente tant que le bouton est maintenu

        else: # bouton relaché
            if (button_press_timer > very_long_press):
                # Arret du lecteur media
                os.system("espeak 'Arrêt de la wéb-radio !' -v fr+f5 -s150 -p 75 -a 300") # Voix synthétique
                subprocess.call(["mpc stop"], shell=True)
                GPIO.output(17, GPIO.LOW) # relais ampli OFF
            elif (button_press_timer > long_press):
                # Pause du lecteur media
                os.system("espeak 'playlist Far Cry Blood Dragon' -v en+f5 -s150 -p 75 -a 300")
                os.system('mpc clear')
                os.system('mpc load FarCryBloodDragon')
                os.system('mpc play')
            elif (button_press_timer > 0):
                # Lecture du lecteur media
                GPIO.output(17, GPIO.HIGH) # relais ampli ON
                os.system('mpc clear')
                   # Chargement de la playlist
                if is_connected(site):
                   # print "Site disponible"
                    os.system('mpc load radio')
                    os.system("espeak 'lecture' -v fr+f5 -s150 -p 75 -a 300")
                    os.system('mpc play 2')
                    fin=time.time()+3600	# attend 1h - 3600
                    fin=round(fin)
                else:
                    #print "Site indisponible"
                    os.system('mpc load foo')
                    os.system("espeak 'lecture' -v fr+f5 -s150 -p 75 -a 300")
                    os.system('mpc play')
                    fin=time.time()+3600	# attend 1h - 3600
                    fin=round(fin)

            button_press_timer = 0
        time.sleep(0.2)

# fonction qui sera appelée quand on appuiera sur le bouton 27
def bouton27(channel):
    # entrée suivante du lecteur media
    os.system("espeak 'station suivante' -v fr+f5 -s150 -p 75 -a 300")
    os.system("mpc next")

# fonction qui sera appelée quand on appuiera sur le bouton 23
def bouton23(channel):
    # entrée précédente du lecteur media
    os.system("espeak 'station précédente' -v fr+f5 -s150 -p 75 -a 300")
    os.system("mpc prev")

# fonction qui sera appelée quand on appuiera sur le bouton 22
def bouton22(channel):
    os.system("sudo poweroff")

# fonction qui sera appelée quand on appuiera sur le bouton 24
def bouton24(a):
    global fin
    button_press_timer = 0
    GPIO.remove_event_detect(24) # empéche le bouton d'etre détecté x fois de plus
    while True:
        if(GPIO.input(a) == GPIO.LOW ): # bouton appuyé
            button_press_timer += 0.2 # incrémente tant que le bouton est maintenu
        else: # bouton relaché
            if (button_press_timer > long_press):
                GPIO.output(4, GPIO.LOW) # relais LCD OFF
                os.system("espeak 'Éteindre lécran LCD' -v fr+f5 -s150 -p 75 -a 300")
                GPIO.output(17, GPIO.LOW) # relais ampli OFF
            elif (button_press_timer > 0):
                os.system('mpc stop')   # stop la radio
                GPIO.output(4, GPIO.HIGH) # relais LCD ON
                GPIO.output(17, GPIO.HIGH) # relais ampli ON
                os.system("espeak 'Allumage de lécran LCD' -v fr+f5 -s150 -p 75 -a 300")
                fin=time.time()+3600       # attend 1h - 3600
                fin=round(fin)

            button_press_timer = 0
        time.sleep(0.2)


# on met le bouton en écoute
GPIO.add_event_detect(27, GPIO.FALLING, callback=bouton27, bouncetime=200)
GPIO.add_event_detect(22, GPIO.FALLING, callback=bouton22, bouncetime=200)
GPIO.add_event_detect(23, GPIO.FALLING, callback=bouton23, bouncetime=100)
GPIO.add_event_detect(24, GPIO.FALLING, callback=bouton24, bouncetime=200)
GPIO.add_event_detect(25, GPIO.FALLING, callback=bouton25, bouncetime=200)

# on lance une boucle infinie, pour garder le script actif
while True:

    if (heure>=fin):
        os.system("mpc stop")
        GPIO.output(17, GPIO.LOW) # relais ampli OFF
        GPIO.output(4, GPIO.LOW) # relais LCD OFF
        fin=9999999999
    else:
        heure=time.time()
        heure=round(heure)

    # une petite pause entre chaque boucle, afin de réduire la charge sur le CPU
    time.sleep(2)

# on réinitialise les ports GPIO en sortie de script
GPIO.cleanup()
  • Le fonctionnement est simple :

- Le bouton 25 pour allumer et éteindre la radio, ou lancer une playlist mp3, par des appuies plus ou moins long (l'ampli audio est géré automatiquement).
- Le bouton 27 pour passer à la station radio suivante.
- Le bouton 23 pour passer à la station radio précédente.
- Et enfin, le bouton 24 pour allumer et éteindre l'écran LCD (et l'ampli audio).
- Lorsque la radio est allumée, soit par l'alarme de l'horloge, ou par le bouton 25, elle fonctionne durant 1h avant de s'éteindre. Idem pour l'écran LCD.
- Si internet n'est pas disponible, la radio bascule sur une playlist mp3 de secours.

  • Pour démarrer automatiquement le programme python dés le démarrage du Raspberry, créer un service pistart.service :
sudo nano /etc/systemd/system/RadioReveil.service
[Unit]
Description=Démarre le script de la webradio
[Service]
ExecStart=/usr/bin/python /home/pi/mpc.py
[Install]
WantedBy=multi-user.target
  • Installer le service :
sudo systemctl --system daemon-reload
sudo systemctl enable RadioReveil.service
  • Pour manipuler le service :
sudo systemctl status RadioReveil.service
sudo systemctl start RadioReveil.service



3 - Installer et configurer Kodi :

Le médiacenter est facultatif, il ouvre cependant sur une galaxie de possibilités…

sudo apt-get install kodi
  • Pour lancer Kodi automatiquement après l'autologin, éditer le fichier .profile :
nano ~/.profile

Et ajouter les lignes suivantes à la fin :

tty=`tty`
# Start Kodi only if login in tty1
if [ $tty = '/dev/tty1' ]; then
        kodi
fi


  • On prendra soins de configurer Kodi dans la résolution vidéo minimale (640x480), mais au vu de la faible résolution de l'écran LCD, il s'avère nécessaire d'afficher de grande police de caractère.

Pour cela éditer :

nano .kodi/addons/skin.confluence/720p/Font.xml

À la sous section <Name> font13, augmenter la valeur <Size> à 50 (initialement réglée à 20).

<name>font13</name>
<filename>Roboto-Regular.ttf</filename>
<size>50</size>

À la sous section <Name> fontContextMenu', augmenter la valeur <Size>'' à 50 (initialement réglée à 18).

<name>fontContextMenu</name>
<filename>Roboto-Regular.ttf</filename>
<size>50</size>

À la sous section <Name> font12_title, augmenter la valeur <Size> à 50 (initialement réglée à 17).

<name>font12_title</name>
<filename>Roboto-Bold.ttf</filename>
<size>50</size>



4 - La télécommande infra-rouge :

Utile au médiacenter, cette partie est donc également facultative !

  • Installer le soft de gestion de l'infrarouge :
sudo apt-get install lirc
  • Éditer hardware.conf pour régler les paramètres de LIRC :
sudo nano /etc/lirc/hardware.conf
########################################################
# /etc/lirc/hardware.conf
#
# Arguments which will be used when launching lircd
LIRCD_ARGS="--uinput"
# Don't start lircmd even if there seems to be a good config file
# START_LIRCMD=false
# Don't start irexec, even if a good config file seems to exist.
# START_IREXEC=false
#Try to load appropriate kernel modules
LOAD_MODULES=true
# Run "lircd --driver=help" for a list of supported drivers.
DRIVER="default"
# usually /dev/lirc0 is the correct setting for systems using udev
DEVICE="/dev/lirc0"
MODULES="lirc_rpi"
# Default configuration files for your hardware if any
LIRCD_CONF=""
LIRCMD_CONF=""
########################################################
  • Activer le module sur le RpiPi en éditant config.txt
sudo nano /boot/config.txt

Dé-commenter la ligne (sans autre argument, c'est le GPIO18 qui sera écouté par le module, sinon pour par exemple le GPIO23, on indiquera dtoverlay=lirc-rpi,gpio_in_pin=23) et redémarrer le RpiPi.

dtoverlay=lirc-rpi
  • Pour tester si les commandes infrarouge sont bien reçues :
sudo killall lircd
sudo mode2 -d /dev/lirc0

Si jamais le programme ça répond ceci :

Using driver devinput on device /dev/lirc0
Trying device: /dev/lirc0
Using device: /dev/lirc0
Partial read 8 bytes on /dev/lirc0

Alors on est en présence d'une Raspbian stretch (9), lircd buggée, pour corriger le problème, lancer le script :

sudo /usr/share/lirc/lirc-old2new
  • À chaque appuie sur une touche de la télécommande, devrait s'afficher ce genre de truc :
space 1223
pulse 281
space 1193
pulse 350
space 1199
pulse 264
space 1901
  • Bien, maintenant on va identifier la télécommande et associer chacun de ses boutons à une touche du clavier. Le programme va demander d'appuyer anarchiquement sur toutes les touches, puis de nommer les touches une à une. La syntaxe à respecter pour les noms est disponible en exécutant :
irrecord --list-namespace

Il est temps de procéder :

sudo irrecord -d /dev/lirc0 telecommande

Suivre la procédure indiquée par le programme…
J'ai choisis ces touches du clavier, qui correspondent aux raccourcis clavier les plus utile de Kodi, pour la simple raison que ça fonctionnera directement ! Pas la peine de configurer quoi que ce soit dans Kodi !

KEY_Up
KEY_Down
KEY_Right
KEY_Left
KEY_Enter
KEY_C (click droit)
KEY_PageUp
KEY_Esc (retour menu principal)
KEY_Back (retour menu précédent)
KEY_Rewind
KEY_Stop
KEY_PlayPause
KEY_FastForward

  • Voici le contenu de telecommande.lircd.conf' qui a été créé, le déplacer dans /etc/lirc/lircd.conf.d/ pour qu'il soit pris en compte par lirc''
begin remote

  name  remoteLongue
  bits           16
  flags SPACE_ENC|CONST_LENGTH
  eps            30
  aeps          100

  header       9053  4449
  one           609  1642
  zero          609   514
  ptrail        608
  repeat       9051  2202
  pre_data_bits   16
  pre_data       0x807F
  gap          108017
  toggle_bit_mask 0x0

      begin codes
          KEY_Up                   0x10EF
          KEY_Down                 0x08F7
          KEY_Right                0x807F
          KEY_Left                 0x30CF
          KEY_C                    0xA05F
          KEY_PageUp               0xB04F
          KEY_Back                 0x20DF
          KEY_Rewind               0x708F
          KEY_Stop                 0x8877
          KEY_PlayPause            0x50AF
          KEY_FastForward          0x48B7
          KEY_Enter                0x00FF
      end codes

end remote
  • Reste à redémarrer le service LIRC
sudo service lircd restart
  • Un moyen simple de savoir si ça marche, c'est de simplement appuyer sur les touches de la télécommande, ça devrait agir dans la console GNU/Linux ![1]

Par exemple la touche correspondant à KEY_C affichera le caractère C, normal quoi, puisque LIRC permet ainsi d'assigner l'entièreté des touches du clavier, et plus encore.

  • Au lancement de Kodi la télécommande devrait fonctionner

Si ce n'est pas le cas, ressortir et vérifier que le processus lircd tourne bien.

ps -A | grep lirc



À suivre…

Note

[1] La console tty de votre choix connecté en HDMI, ça ne fonctionne pas depuis ssh !

- page 2 de 74 -