Archives du blog

Migration des repository du blog

Jusqu’à présent le code que j’ai pu vous présenter était hébergé chez google code. Or Google a décidé de fermer ce service.

J’ai donc décidé de migrer les repository mes-projets-arduino et mes-projets-raspberry vers gitlab. gitlab a l’avantage de permettre de créer des projets privés dans sa formule gratuite.

Pour ce faire j’ai suivi les grandes lignes de ce tutoriel.

Dans les grandes lignes j’ai rééxtrait mes projets depuis google code avec git-svn

git svn clone https://mes-projets-raspberry.googlecode.com/svn/trunk mes-projets-raspberry

j’ai vérifié que rien n’était oublié par rapport à mon répertoire local (normalement pas nécessaire, mais bon …). Pour ça j’ai utilisé l’excellent « meld ».

enfin j’ai fait un push des sources

git remote add origin git@gitlab.com:steftech/mes-projets-raspberry.git
git push -u origin master

Mes sources sont accessibles maintenant via :
https://gitlab.com/steftech/mes-projets-raspberry
https://gitlab.com/steftech/mes-projets-arduino

Publicités

Cloner une télécommande Radio Fréquence (433MHz) – Part 2

Après avoir vu comment récupérer une trame émise par une télécommande Radio Fréquence je vais vous montrer comment remplacer la télécommande avec un raspberry Pi.

Montage pour envoi (simplisme)

Le montage est ultra simple, le VCC de l’emetteur vers le 3,3V du raspi, le GND de l’emetteur vers le GND du raspberry et enfin le port DATA de l’emetteur vers le port 17 du raspi.
Je remets ici le diagramme des ports GPIO et leur notation (tout du moins pour la version 2 du raspberry pi)

Diagramme du port GPIO pour le Raspberry Pi version 2

Diagramme du port GPIO pour le Raspberry Pi version 2

Programme Python pour envoi code

La librairie RPi.GPIO est nécessaire, elle est dans les dépots de la raspian, pour les autres distrib veuillez vous adresser auprès de sa communauté.

 apt-get install python-rpi.gpio

La doc de cette librairie est ici : http://pythonhosted.org/RPIO/rpio_py.html#ref-rpio-py

#!/usr/bin/python
# -*- coding: utf-8 -*-

import RPi.GPIO as GPIO
import time
import sys



class RF :
	
	tableau = { "AVIDSEN" : 
				{ "echantillonnage" : 44100,
				  "bits" : 
					{ 0 : [ [ 52, 0 ], [ 22, 1 ] ] ,
					  1 : [ [ 22, 0 ], [ 52, 1 ] ] },
				  "buttons" : 
					{ "1 ON"  : "011111111111100101101",
					  "1 OFF" : "011111111111100111100",
					  "2 ON"  : "011111111111110101111",
					  "2 OFF" : "011111111111110111110",
					  "3 ON"  : "011111111111111101110",
					  "3 OFF" : "011111111111111111111",
					  "4 ON"  : "011111111111100001111",
					  "4 OFF" : "011111111111100011110",
					  
					}
				}
			}
	
	paramBits = {}
	dataPin    = 17
	tempsPerdu = 0
	nb_retry   = 4
	# Nombre de secondes d'attente entre deux retry
	attenteEntrePaquets = 0.075
	
	def __init__(self, dataPin ):
		self.dataPin = dataPin
		GPIO.setwarnings(False) 
		GPIO.setmode(GPIO.BCM)
		GPIO.setup(self.dataPin, GPIO.OUT)

	def sendDataPulse( self, dataPin, duration, value ):
		if value == 1 :
			GPIO.output(dataPin, GPIO.HIGH)
		else:
			GPIO.output(dataPin, GPIO.LOW)
		time.sleep( duration )

	def send( self, marque, button ):
		
		# Précalcul les attentes pour chaque type de bits
		for valeur in range(0, 2):
			self.paramBits[ valeur ] = [] 
			for paramBit in self.tableau[marque]["bits"][valeur]:
				tempsAttente  = 1.0 * ( paramBit[0] - self.tempsPerdu) / self.tableau[marque]["echantillonnage"]
				self.paramBits[valeur].append( [ tempsAttente , paramBit[1] ] )
		
		self.sendDataPulse( self.dataPin, 0.01 , 0 )
		for i in range( 0, self.nb_retry ) :
			for bit in self.tableau[marque]["buttons"][ button ]:
				for paramBit in self.paramBits[ int( bit ) ]:
					self.sendDataPulse ( self.dataPin, paramBit[0], paramBit[1])
			self.sendDataPulse( self.dataPin, 0.01 , 0 )
			time.sleep( self.attenteEntrePaquets )
		self.sendDataPulse( self.dataPin, 0.01 , 0 )

	def __del__(self):
		GPIO.cleanup()

if __name__ == "__main__" :
	marque = "AVIDSEN"
	button = "1 ON"
	
	if len(sys.argv) > 2:
		marque = sys.argv[1]
		button = sys.argv[2] + " " + sys.argv[3]
	else :
		print "arguments incorrects :"
		print sys.argv[0] + " <marque> <id> <position>"
		sys.exit(1)

	rf = RF( 17 )
	rf.send( marque, button )

Quelques petites choses sont à adapter pour votre télécommande, j’ai essayé de les regrouper dans la variable « tableau » ( ouh que ce nom est mal choisi !).

tableau = { "AVIDSEN" : 

AVIDSEN est le petit nom de la télécommande, j’ai donné le nom de la marque, je n’ai aucune imagination pour les noms 😉

				{ "echantillonnage" : 44100,

Le taux d’échantillonnage utilisé dans Audacity est noté ici, les temps seront notés en « samples » (il est facil d’adapter cette partie pour mettre des secondes à la place, je me tâte d’ailleurs de mettre un nombre de µs à la place).

				  "bits" : 
					{ 0 : [ [ 52, 0 ], [ 22, 1 ] ] ,
					  1 : [ [ 22, 0 ], [ 52, 1 ] ] },

C’est la partie qui me dérange le plus, car partant de bases théoriques que je pensais sûres (un nombre de points sur un enregistrement Audacity), cela ne marchait pas. Le raspberry pi n’est pas capable d’attendre un nombre de µs fiable, l’attente de 55 samples était trop long, j’ai du descendre à 52 de façon empirique (et les autres valeurs aussi). En effet nous ne sommes pas sur un système temps réel, c’est à dire que le programme d’envoi n’est pas seul à tourner sur la machine, d’autres vont le ralentir et ce de façon non prédictive. Ajoutons à ça des lib pythons qui ne sont pas forcement aussi rapides que du C du coup j’espère que le service sera viable.

				  "buttons" : 
					{ "1 ON"  : "011111111111100101101",
					  "1 OFF" : "011111111111100111100",
					}

La trame capturée à l’aide d’Audacity est stockée ici, brute de fonderie. Je n’ai pas trouvé le logique entre le bouton ON et le bouton OFF, alors j’ai pris le parti de stocker la trame complète.

Pour utiliser ce programme il fonctionne en ligne de commande

 python RF.py "AVIDSEN" 1 ON 

, mais il est aussi possible de l’utiliser comme une librairie pour un autre programme python.

Comme d’habitude cet article est un travail empirique qui peut ne pas fonctionner chez les autres (en somme il est sous licence Demerdenzizich que les Anglo Saxon appelle As-Is)

La troisième partie concernera l’utilisation d’une télécommande Blyss avec un code roulant.

Un système audio pour la maison [Part 3]

Apres avoir vu (rapidement) les avantages des squeezebox, installé le serveur et les client, je vous propose donc d’ajouter deux petites choses à notre installation :

Un DAC

pour avoir un son de meilleur qualité. En raccordant le tout à une chaîne Hifi on obtiendra un son tout a fait correct (bon … je ne suis pas un audiophile, mais il me suffit tout à fait 😉 ). Le DAC va remplacer la carte son interne du Pi, qui n’est pas exceptionnelle.

A la suite de conseils précieux j’ai commandé un mini GAMAX pour 37$ sur dhgate (made in china c’est  sûr 😉 ) , cette petite bête est de la taille du Pi et propose :

  •  une entrée USB (qu’on reliera au Pi)
  • une sortie Jack
  • une sortie coax
  • une double sortie RCA (L/R)
  • une sortie numérique
  • une entrée micro

J’alimente ce petit boitier avec une vielle alimentation 12V qui correspond pil poil à ce que veut le DAC (9-24V avec le + au milieu).

Coté reconnaissance par le Pi il n’y eu aucun soucis. J’ai branché et squeezelite permet de vérifier sa présence :

squeezelite-armv6 -l

cela donne :


Output devices:
null - Discard all samples (playback) or generate zero samples (capture)
default:CARD=Set - C-Media USB Headphone Set, USB Audio - Default Audio Device
sysdefault:CARD=Set - C-Media USB Headphone Set, USB Audio - Default Audio Device
front:CARD=Set,DEV=0 - C-Media USB Headphone Set, USB Audio - Front speakers
surround40:CARD=Set,DEV=0 - C-Media USB Headphone Set, USB Audio - 4.0 Surround output to Front and Rear speakers
surround41:CARD=Set,DEV=0 - C-Media USB Headphone Set, USB Audio - 4.1 Surround output to Front, Rear and Subwoofer speakers
surround50:CARD=Set,DEV=0 - C-Media USB Headphone Set, USB Audio - 5.0 Surround output to Front, Center and Rear speakers
surround51:CARD=Set,DEV=0 - C-Media USB Headphone Set, USB Audio - 5.1 Surround output to Front, Center, Rear and Subwoofer speakers
surround71:CARD=Set,DEV=0 - C-Media USB Headphone Set, USB Audio - 7.1 Surround output to Front, Center, Side, Rear and Woofer speakers
iec958:CARD=Set,DEV=0 - C-Media USB Headphone Set, USB Audio - IEC958 (S/PDIF) Digital Audio Output
default:CARD=ALSA - bcm2835 ALSA, bcm2835 ALSA - Default Audio Device
sysdefault:CARD=ALSA - bcm2835 ALSA, bcm2835 ALSA - Default Audio Device

A vous de choisir votre sortie préférée suivant votre DAC . Je me suis cantonné à « sysdefault:CARD=Set » que j’ai mis dans le script de démarrage que je vous avait donné précédemment (/etc/initi.d/squeezelite-arm6  : variable SLOPTIONS)

Une télécommande

Pour cela j’utiliserai lirc, le port GPIO du Raspberry Pi et un TSOP 4838 (d’autres marcheront peut être, mais je n’en sais rien 😉 )

Le matériel

Le montage à utiliser est détaillé chez Adafruit, vous n’êtes pas du tout obligé d’utiliser cette télécommande. Personnellement j’ai recyclé celle d’un vieux lecteur CD mort depuis longtemps.

Si vous suivez le montage d’adafruit il suffit de connecter GND, 3,3V et le data du TSOP (recepteur IR 38kHz) aux ports adéquats du Pi (le Data utilisé est le n°18) .

Le Système

sudo modprobe lirc_rpi

chargera le module nécessaire pour lirc.
Edit : Ce module est à rajouter au fichier /etc/modules pour qu’il soit chargé automatiquement au démarrage du Raspberry Pi

vérifiez avec un

mode2 -d /dev/lirc0

que votre Pi reçoit bien les infos venant de la télécommande (appuyez et viser 😉 )

L’apprentissage de la télécommande

Sans doute la plus grosse partie du boulot qui reste à faire.

sudo irrecord -d /dev/lirc0 /etc/lirc/lircd.conf

La première phase va permettre de reconnaitre le protocole employé par la télécommande, il ne s’agit pas spécialement d’appuyer sur toutes les touches. Les informations à l’écran sont à lire (il faut toujours lire ce qui est affiché à l’écran 😉 )

La seconde phase est plus « laborieuse », il va falloir associer les touches une par une. Le programme demande un « mnémonique » tel que KEY_PLAY, KEY_STOP, … (la liste complète est trouvable grâce à

irrecord –list-namespace

).

Une fois l’apprentissage de toutes les touches effectuées il va falloir « câbler » ça avec squeelite

Donnons des ordre à squeezelite

Pour cela je vais utiliser le fichier de configuration de irexec : /etc/lirc/lircrc


begin
prog = irexec
button = KEY_PLAY
config = /usr/local/ir2squeeze/pause
end

begin
prog = irexec
button = KEY_NEXT
config = /usr/local/ir2squeeze/next
end

begin
prog = irexec
button = KEY_PREVIOUS
config = /usr/local/ir2squeeze/previous
end

begin
prog = irexec
button = KEY_POWER
config = /usr/local/ir2squeeze/power
end

J’associe donc à chaque touche un script shell qui va être appelé, de ce fait ma télécommande peut faire plus ou moins n’importe quoi !!!!

I except you know Expect

Pour piloter squeezelite je ne vais pas faire dans la dentelle (pour le moment), un script par touche. Et pour me faire comprendre je vais directement utiliser le protocole réseau avec une commande telnet. Pour ça il y a un utilitaire magnifique que j’ai découvert il y a peu : Expect

d’abord on va l’installer

apt-get install expect

Exemple du script /usr/local/ir2squeeze/pause :

#!/usr/bin/expect

spawn telnet 192.168.X.X 9090
expect "Escape character is *"
send "AA:BB:CC:DD:EE:FF pause\n"
expect "* pause"
send "exit\n"
expect eof

où 192.168.X.X est l’adresse IP du serveur squeezebox et AA:BB:CC:DD:EE:FF l’adresse MAC de la machine cliente. Cette adresse MAC peut être trouvée dans l’écran information du serveur ou par un ifconfig -a sur le client, ça tombe bien c’est celui sur lequel vous travaillez actuellement.

Edit : Afin que lirc démarre en même temps que votre système il faut le rajouter dans le mécanisme d’init.d.

ln -s /etc/init.d/lirc /etc/rc2.d/S15lirc

Le démarrage de lirc peut se faire à l’aide de la commande classique :

sudo service lirc

Je ne suis pas rentré dans tout les détails techniques  mais cela devrait vous donner quelques pistes pour (peut-être) faire fonctionner votre Pi en tant que squeezebox 😉

Un système audio pour la maison [Part 1]

Suite à un article trouvé chez Korben j’ai découvert la distribution Raspifi qui a pour but de lire ses mp3 à l’aide d’un rasperry pi.

La distrib s’installe sans trop de problème et j’ai pu lire les mp3 qui sont sur mon NAS.

N’ayant pas été convaincu par l’interface web de l’engin j’ai été aiguillé vers la solution de Logitech.

Bon disons le tout de suite, c’est une solution  propriétaire, donc qui pourrait disparaître à tout moment. Mais j’ai rarement vu une interface propriétaire qui autorise autant de possibilité, on est plutôt dans l’ère de la Pomme avec un simple bouton Play (pour les autres c’est en option 😉 ).

Cette solution réside sur une solution client/serveur et impose donc de laisser tourner un PC tout le temps. Vu que c’est déjà le cas pour moi ça ne me dérange pas ;). Il permet de lire des mp3, mais aussi des web radios (ce qui rejoint un de mes précédents articles).

Le serveur

De son petit nom « Logitech Media Server », il se télécharge sur le site du fabriquant de souris, et s’installe sous Linux (DEB ou RPM), Mac, Windows et quelques NAS. Une fois installé il faut s’enregistrer sur le site de logitech, cela permettrait théoriquement de contrôler les squezebox depuis internet. Dans les faits je n’ai jamais réussi à partir de ce site, mais ce n’est pas grave 😉 . Ensuite on lui faire indexer ses mp3, c’est assez classique. Il y a possibilité d’ajouter des plugins, des interrogations vers last.fm ou d’autre, … les possibilité sont assez étendues.

En l’état le système ne fonctionne pas, on a pas la possibilité de lire de mp3, pour cela il faut un (ou plusieurs clients)

Le client (payant)

Logitech ne faisant pas ça gratuitement compte quand même vendre du matos,en l’occurrence il s’agit des Squeezebox Radio. A priori la gamme était plus vaste il y a quelques années mais la marque a recentré sa stratégie 😦

J’ai donc acheté une Squeezebox Radio pour la cuisine. La petite bête est sympathique avec son Wifi et du son mono de bonne qualité. Disponible aux alentours de 130€ ça peut refroidir, mais je ne regrette pas du tout mon achat.

L’ergonomie de la petite bête est très agréable et dispose d’un excellent WAF ce qui fait qu’elle a été adoptée par madame de façon surprenante.

Le client (gratuit)

Là où la chose est beaucoup plus intéressante, c’est qu’il est possible d’installer squeezelite sur son ordinateur (ou sur un raspberry pi, mais j’y viendrais plus tard). à partir de ce moment là il est possible de streamer de la musique sur l’ordinateur depuis le serveur.

Et il peut y avoir plusieurs clients en même temps. Par exemple un serveur familiale avec la musique et des raspberry dans les autres pièces  raccordés aux enceintes.

D’ailleurs cette multitude de client a un fonctionnalité que je n’avais jamais vu avant c’est la « synchonisation » des clients. Par un menu il est possible d’indiquer que deux clients vont diffuser les mêmes programmes, idéal quand on se déplace dans la maison, une sorte de radio d’intérieure en somme.

Les interfaces

Afin de piloter la lecture il y a aussi foultitude de possibilité, on peu se connecter sur le site web de logitech (même si ça ne marche pas chez moi), on peu se connecter au serveur (et choisir sur quel client la lecture se passera). Il existe aussi des interfaces pour Android (même topo), la squeezebox radio est aussi autonome de ce coté là (mais peut aussi être pilotée par le réseau. Enfin il est aussi possible de piloter via le protocole réseau qui est disponible sur le Net (j’en reparlerais plus tard).

Et ceci n’est que le commencement … à suivre

Brochages Arduino et Raspberry Pi

Un petit article bookmark pour citer deux liens particulièrement utiles.

[*] Les brochages de l’arduino, des Atmega328 mais aussi des attiny, à garder à portée de main

http://www.semageek.com/pratique-des-diagrammes-de-pinout-pour-arduino-et-atmega/

[*] Un petit PDF à découper et à enficher sur le port GPIO de votre Raspberry Pi, un must have pour ceux qui n’ont pas de Pi Cobbler

http://www.doctormonk.com/2013/02/raspberry-pi-and-breadboard-raspberry.html