Archives Mensuelles: mai 2013

Utilisation des Attiny

J’ai creusé du coté des Attiny pour avoir les même fonctionnalité que l’Arduino mais en moins cher.

J’ai retenu pour le moment l’Attiny 45 et le 85. Ces deux microcontroleurs ne disposent que de 8 pattes ce qui en fait un excellent moyen de diminuer la taille de ses montages. J’ai réussi à trouver sur ebay des Attiny 85 avec leurs sockets à moins de 2€ pièce (frais de port compris), par rapport à un arduino c’est déjà ça de gagné ! A noter qu’ils existent en plusieurs type de « casing », j’ai opté pour les ATTINY85-20PU.

Par contre ces petites machines sont limitées, j’ai bloqué sur l’Attiny 45 et sa limite de 4Ko de flash. En tentant de compiler un exemple simple utilisant RC-switch ( librairie de communication RF en 433 MHz) je n’ai pas réussi à descendre en dessous des 4Ko.

De plus les Attiny de la série X5 n’ont que 5 broches utilisables. Si votre projet en utilise plus vous pouvez regarder du coté des Attiny 44 et 84 ont plus de broches (mais pas plus de mémoire) ou directement des Atmgea328.

Bref, pour utiliser l’Attiny il suffit de suivre le tutoriel suivant :http://www.semageek.com/tuto-programmation-des-attiny45-avec-un-arduino/

Ce tutoriel est simple à suivre, un petit montage à faire, un programme à charger sur l’Arduino, quelques paramétrage de l’IDE de l’Arduino, le bootloader à charger sur l’Attiny et c’est parti.

EDIT du 3 juin : Et voici une version « propre » que j’ai réalisée à partir d’un Protoshield achetée sur Ebay. Le plus long a été de dessouder les connecteurs du dessus 😉

Programmateur Attiny

Programmateur Attiny

Publicités

Faire de son Raspberry Pi une Web Radio

Pour faire une web Radio j’ai utilisé les capacités du lecteur « mpd » (je ne détaille pas l’explication de l’installation de mpd, « apt-get install mpd mpc »).

Pour commencer j’ai ajouté une web radio :
mpc add http://streaming.radio.rtl2.fr:80/rtl2-1-44-128

Ensuite j’ai réalisé un petit montage pour ajouter un écran LCD et quelques boutons.

Maestro

Câblage d’un écran LCD et de 4 boutons sur un Raspberry Pi

J’ai trouvé un bout de code Python permettant de gérer un écran LCD de type « HD44780 » (disponible sur ebay pour quelques euros) sur zem.fr . J’ai juste mis le code dans un module Python indépendant (LCD.py).

Les codes sources sont disponible dans mon nouveau repository dédié au Raspberry Pi (vu que je développe directement dessus, j’ai préféré le séparer du repository Arduino). Le Programme s’appelle Maestro et utilise pour le moment quatre boutons, l’un pour faire Pause/Play le second pour Next (changement de station) et les deux derniers pour la gestion du volume.

Il est tout à fait possible d’ajouter ou d’enlever des boutons dans le code, chaque bouton est un objet qui est défini par le port GPIO à utiliser pour le câblage et une fonction de callback.
Dans l’init du GUI, je défini un bouton. Ce bouton restera en attente de ce qui se passe sur un port GPIO. Il a son propre Thread pour la surveillance. A voir si augmenter le nombre de bouton dégrade les performances.

self.bouton4 = Button( 22, self.Button4Pressed )
self.bouton4.start()

Et la fonction de callback qui va augmenter le volume

 def Button4Pressed(self):
  os.system("mpc volume +10")

Le code est volontairement simpliste et ne fait appel qu’a mpc pour le contrôle. Je pars du principe qu’on ne va pas « spammer » les boutons et que le raspberry sera peu ou prou dédié à cette tache.

Je ne sais pas encore si j’utiliserais ce « mini projet », mais s’il s’avère que c’est le cas j’ai dans l’idée d’ajouter un bouton qui ferait passer du mode radio à un mode playlist. Cela permettrait de « meubler » quand la radio diffuse une pub ou une chanson qui ne me plait pas.

Edit : Dans les faits j’utilise effectivement un raspberry Pi pour lire de la musique au salon mais en utilisant un autre système que je décris ici

Mettre de la couleur dans vos shell en perl

En balayant mes archives je tombe sur une librairie que j’avais écrite il y a quelques années.

Elle permet de changer « simplement » les attributs d’un texte écrit par un script shell Unix (ou Linux).
La librairie propose 4 fonctions :

  • color_fg_set_str , modifie la couleur d’écriture du texte
  • color_bg_set_str , modifié la couleur de fond d’écran du texte
  • curs_pos_str , déplace le curseur
  • decoration_set_str , bascule en gras, souligné, clignotant, …

use constant ESC_FMT		=> "\033[%sm";
use constant ESC_FMT1	=> "\033[%dm";
use constant ESC_FMT2	=> "\033[%d;%dm";
use constant ESC_FMT3	=> "\033[%d;%d;%dm";
#use constant CLR_SCR		=> "\f";
use constant CLR_SCR		=> "\033[2J";
use constant CLR_EOL		=> "\033[K";
use constant POS_CUR		=> "\033[%d;%dH";
use constant CUR_SAV		=> "\033[s";
use constant CUR_RES		=> "\033[u";
use constant FLUSH		=> CUR_SAV . "\n" . CUR_RES;
use constant ESC_FMTC1	=> "\033[%d%s";
use constant ESC_FMTC2	=> "\033[%d;%d%s";
use constant ESC_DEFAULT	=> "\033[0m\033[37;40m";

#	DECORATIONS
use constant OFF	  	=>  0;
use constant BOLD		  =>  1;
use constant UNDER	  =>  4;
use constant BLINK	  =>  5;
use constant REVERSE	=>  7;
use constant CONCEAL  =>  8;

#	COULEURS
use constant BLACK		=>  30;
use constant RED			=>  31;
use constant GREEN		=>  32;
use constant YELLOW		=>  33;
use constant BLUE			=>  34;
use constant MAGENTA	=>  35;
use constant CYAN			=>  36;
use constant WHITE		=>  37;

sub color_fg_set_str
{
	my $color = shift;	#couleur désiré
	$color = $default_fg_color if (! $color);
	if ($color >= BLACK && $color <= WHITE)	# couleur connue
	{
		return sprintf ESC_FMT1, $color;				# changement de couleur
	}
	return "";
}

sub curs_pos_str
{
	my ($lig, $col)= ( @_ );

	if ( $lig > 0 and $col > 0 )
	{ return sprintf(POS_CUR, $lig, $col); }
	else
	{	return ""; }
}

sub color_bg_set_str
{
	my $color = shift;	#couleur désiré
	$color = $default_bg_color if (! $color);
	if ( ( $color>=BLACK && $color<=WHITE ) )	# couleur connue
	{
		return sprintf ESC_FMT1, ($color + 10);			# changement de couleur
	}
	return "";
}

sub decoration_set_str
{
	my $decoration = shift;	#decoration désiré
	$decoration = $default_decoration if (! $decoration );
	if ( ( $decoration>=OFF && $decoration<=CONCEAL ) )	# decoration connue
	{
		return sprintf ESC_FMT1, ($decoration);			# changement de decoration
	}
	return "";
}


En espérant que cela serve à quelqu’un un jour

PS : Une mine d’info https://wiki.archlinux.org/index.php/Color_Bash_Prompt

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

Ajout d’un Ecran LCD sur ma Timelapse-Machine

J’avais détaillé il y a quelques mois comment réaliser un timelapse avec Arduino . J’ai depuis fait évoluer le montage pour utiliser un écran LCD et un bouton pour gérer les temps d’attente entre chaque prise de vue.

Dans la précédente approche j’utilisais un potentiomètre pour régler le temps entre chaque prise de vue. Or cette méthode se révèle à l’usage peu pratique. Le potentio n’est pas très sensible, une pichenette le fait passer de 1 à deux minutes entre chaque prises, et il surtout est facile de faire une fausse manip et le dérégler.
J’ai donc choisi une autre méthode en définissant des plages pré programmée. La liste que j’ai retenu est la suivante (temps en secondes) : 5, 10, 30, 60 (1 min), 120 (2 min), 300 (5 min), 600 (10 min), 1800 (30 min). Cette liste est « en dur » dans le code, mais ce n’est pas bien difficile de la faire évoluer (chez soi, certes, quand on fait des prises de vue à l’extérieur c’est mort 😉 )
Chaque pression sur le bouton modifie le timer de l’arduino vers la valeur suivante dans cette liste.

Pour pouvoir visualiser le temps sélectionné j’ai utilisé un petit LCD trouvé sur ebay à 2-3€ pièce : le HD44780.

Timelapse LCD en boite

Shield sur l’arduino dans son ravissant écrin en carton

Le montage n’est pas bien différent du précédent, j’ai juste câblé l’écran et un bouton

Le bouton est entre le pin 2 et les 5V

Le LCD :

VSS GND
VD 5V
V0 4.7k Ohm => GND
RS pin 12
RW GND
E pin 11
D0 non connecté
D1 non connecté
D2 non connecté
D3 non connecté
D4 pin 7
D5 pin 6
D6 pin 5
D7 pin 4
A 150 Ohm => +5V
K GND

J’ai utilisé une résistance fixe de 150 Ohms pour relier l’Anode (A) au +5V, cela joue sur le contraste de l’écran. Ce choix peut être différent chez vous. Vous pouvez aussi utiliser un potentiomètre pour le rendre réglable.

Le code est disponible sous mon repository Arduino et comme d’habitude vous pouvez le reprendre à votre sauce.