Born to be wired
731831 visites
Uptime 77 days

Articles taggés avec ‘DIY’

 Winter is coming – S01E01

 14 octobre 2013  Domotique  1 commentaire »
house-stark-winter-is-comming

L’hiver vient. Après avoir automatisé le démarrage et l’arrêt des radiateurs de mon appartement grâce à l’installation de fils pilotes et d’une centrale de programmation, je souhaite vivement mettre en place une fonctionnalité similaire sur ma climatisation réversible. Elle constitue pour moi un moyen économique et rapide de chauffer ma pièce principale, il serait donc intéressant de pouvoir la déclencher de manière programmée, ou encore mieux, à distance, par exemple de manière automatique le matin avant que je me lève, ou manuellement à l’heure où je sors du travail, afin que la pièce soit déjà chauffée lorsque j’arrive chez moi.

Seulement, mettre en place un tel projet n’est pas évident. Ma clim de marque Airton n’est pas programmable. Je ne peux pas non plus automatiser son déclenchement en connectant son alimentation sur des relais, cela équivaudrait à couper brutalement le courant lorsque je demande un arrêt, ce qui n’est pas conseillé quand le climatiseur est activé.

Ma seule possibilité d’interaction avec l’appareil reste sa télécommande. Je dois donc trouver un moyen de récupérer les codes infrarouges envoyés par la télécommande et de les faire reproduire par un second dispositif automatisable.

Pour récupérer les codes de la télécommande d’origine, j’ai choisi de ressortir mon Arduino, qui jusqu’ici ne m’avait pas encore beaucoup servi, et de lui connecter un récepteur infrarouge issu d’un petit kit de développement commandé chez DealExtreme. J’ai effectué le câblage de la manière suivante :

ir-receiver-breadboardir-receiver-schematicsJe précise, pour ceux qui ne connaissent pas et qui voudrait réaliser des plans de câblage similaires, que ces schémas ont été réalisés avec le fabuleux Fritzing. Attention, selon le type de récepteur infrarouge utilisé, le brochage peut varier. Vérifiez la notice du composant en cas de doute.

J’ai récupéré et utilisé la bibliothèque de commande infrarouge pour Arduino développée par Ken Shirriff sur la page GitHub associée. Le blog de Ken Shirriff regorge également d’excellentes explications sur l’utilisation de cette bibliothèque.

J’ai enfin compilé et déployé le code suivant sur l’Arduino. C’est du quick and dirty, pour le test :

#include <IRremote.h>
int RECV_PIN = 11; //define input pin on Arduino
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup()
{
	Serial.begin(9600);
	irrecv.enableIRIn(); // Start the receiver
	irrecv.blink13(true); // Blink LED 13 during IR reception
}

// Dumps out the decode_results structure.
// Call this after IRrecv::decode()
void dump(decode_results *results) {
	int count = results->rawlen;
	if (results->decode_type == UNKNOWN) {
		Serial.print("Unknown encoding: ");
	}
	else if (results->decode_type == NEC) {
		Serial.print("Decoded NEC: ");
	}
	else if (results->decode_type == SONY) {
		Serial.print("Decoded SONY: ");
	}
	else if (results->decode_type == RC5) {
		Serial.print("Decoded RC5: ");
	}
	else if (results->decode_type == RC6) {
		Serial.print("Decoded RC6: ");
	}
	else if (results->decode_type == PANASONIC) {
		Serial.print("Decoded PANASONIC - Address: ");
		Serial.print(results->panasonicAddress,HEX);
		Serial.print(" Value: ");
	}
	else if (results->decode_type == JVC) {
		Serial.print("Decoded JVC: ");
	}
	Serial.print(results->value, HEX);
	Serial.print(" (");
	Serial.print(results->bits, DEC);
	Serial.println(" bits)");
	Serial.print("Raw (");
	Serial.print(count, DEC);
	Serial.print("): ");

	for (int i = 0; i < count; i++) {
		if ((i % 2) == 1) {
			Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
		}
		else {
			Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC);
		}
		Serial.print(" ");
	}
	Serial.println("");
}

void loop() {
	if (irrecv.decode(&results)) {
		Serial.println(results.value, HEX);
		dump(&results);
		irrecv.resume(); // Receive the next value
	}
}

La carte est maintenant prête à recevoir les codes de quelques télécommandes. Afin d’afficher les codes IR reconnus par le dispositif, il est nécessaire de lancer le moniteur série de l’éditeur Arduino.

Montage sur platine d'essais, on ne peut plus simple.

Montage sur platine d’essais, on ne peut plus simple.

La plupart des télécommandes que j’avais sous la main ont été reconnues par le récepteur, à l’exception de ma télécommande Xbox. La LED du récepteur clignote lorsqu’il reçoit un signal IR. C’est d’ailleurs ce qui m’a permis de constater que mon écran PC parasitait le récepteur, j’ai donc pris soin de conserver une distance suffisante entre les deux appareils pour mes tests.

Je me suis par la suite focalisé sur le décodage des codes IR reçus, et affichés dans moniteur série. Sans surprise, la télécommande DealExtreme affiche les codes de télécommande NEC, tels que l’indique sa documentation.

La télécommande de mon climatiseur Airton est également reconnue comme utilisant le protocole NEC. En cherchant des informations sur ce protocole, j’ai trouvé entre autres cette synthèse, très bien réalisée. Elle m’a alors permis de vérifier si les codes IR reçus étaient cohérents par rapport au protocole reconnu.

decoded-ir-codes-with-raw-data

Attention, là, ça devient un poil technique :

La synthèse du protocole NEC m’apprend que celui-ci transmet une information sur 4 octets (soit 32 bits), plus un en-tête et un stop bit. Chaque bit 0 ou 1, ainsi que l’en-tête et le stop bit, sont codés par un niveau actif (émission de lumière IR) suivi d’un niveau inactif (pas d’émission de lumière), la durée de chacun de ces niveaux déterminant le type de bit codé. Pendant un niveau actif, l’émission de lumière n’est pas continue mais pulsée à la fréquence de 38 kHz. Enfin, sur les 4 octets, seuls 2 comportent une information utile, puisque les 2 autres contiennent un XOR de l’octet précédent avec 0xFF. Pour les novices en informatique, le XOR est un OU EXCLUSIF logique bit à bit, et n’a aucun rapport avec un personnage de fiction exerçant la profession de shérif de l’espace. Ici un XOR avec 0xFF revient à inverser chaque bit, donc 0 devient 1 et 1 devient 0.

Ainsi par exemple, au niveau de ma télécommande DealExtreme, le premier code remonté est FFA25D, ce qui correspond en réalité à une réception de 00FFA25D exprimé avec 32 bits. Les 4 octets sont 0x00, 0xFF, 0xA2, 0x5D. Le premier octet représente l’adresse (0), le second 0xFF correspond bien à l’inversion bit à bit de 0x00, le troisième octet 0xA2 représente la commande, et le quatrième 0x5D correspond bien à l’inversion bit à bit de 0xA2. Notez que la commande reçue 0xA2 est exprimée en LSB-first, bit de poids faible transmis en premier, et que si on la convertit en MSB-first, bit de poids fort transmis en premier comme l’être humain moyen a l’habitude de manier les nombres (en général on écrit les dizaines à gauche des unités), on obtient le code logique de commande 0x45, soit 69 en décimal.

La commande reçue correspond donc à un code 69 envoyé à l’adresse 0. Fin de la plongée dans le détail du protocole.

Si je regarde maintenant les codes reçus correspondants aux appuis de touches sur ma télécommande Airton, 2 points m’interpellent :

  • J’ai appuyé sur plusieurs boutons de ma télécommande, et tous sont décodés comme 6A8E0000 par le dispositif. Tous les boutons qui envoient le même code, c’est louche.
  • Au niveau de la structure du code reçu, si 0x6A est l’adresse, alors son inversion bit à bit devrait être 0x95, et non pas le 0x8E obtenu. De même, l’inversion bit à bit de 0x00 devrait être 0xFF, et non pas le 0x00 obtenu. Il y a donc vraiment quelque chose qui cloche.

Forcément, je m’attendais à ce que cela ne soit pas simple. La bonne nouvelle pour moi, c’est que le signal envoyé par la télécommande est bien perçu par le récepteur. La mauvaise, c’est que le récepteur ne semble pas décoder ce signal de la bonne façon. Il faut donc investiguer sur la bibliothèque de commande infrarouge, comprendre comment elle fonctionne, et probablement la modifier pour l’adapter aux spécificités de ma télécommande Airton. Mais ça, c’est pour une prochaine fois.

 Youfo : le front-end pour Youpi

 13 septembre 2011  Bricolage  3 commentaires
L'interface utilisateur de Youfo

Avec la fin de mes travaux sur le back-end du robot Youpi, sauf remontée de bugs éventuelle, j’étais arrivé à la conclusion que je pouvais enfin passer à autre chose. Mais en même temps, j’avais sous la main un back-end plutôt abouti et pas avare en possibilités, et rien d’autre pour faciliter la manipulation du robot ou l’élaboration de scripts.

Je devais me rendre à l’évidence : il fallait que je réalise rapidement un petit front-end pour que le sujet soit bouclé. Libre ensuite aux gens de l’utiliser, de l’autopsier, et de l’adapter.

J’ai voulu un front-end pour un pilotage à la souris qui soit dans la mesure du possible léger et multiplateformes. Quoi de mieux qu’un front-end client léger accessible depuis n’importe quel navigateur — N’importe quel navigateur récent, s’entend. Fuck off IE6.

C’est de cette manière qu’est né Youfo (pour YOUpi FrOnt-end), une interface web ridiculement sobre, développée en quelques heures, articulée autour du framework jQuery et communiquant avec le back-end grâce à des messages Ajax/JSONP.

L'interface utilisateur de Youfo

L’interface utilisateur de Youfo

L’interface permet de piloter chacun des moteurs en cliquant sur le bouton approprié. Pour le fun, lors d’un survol des boutons, la partie du robot concernée par le mouvement se colorise sur l’image d’à côté.

En plus de cet aspect « pilotage en temps réel », à chaque fois que la position de l’ensemble du robot est satisfaisante, un clic sur le bouton au centre de l’écran permet de récupérer la position de tous les moteurs et enrichit le script dans la zone de texte. Il est ainsi possible de copier/coller le contenu de cette zone dans un shell qui, lorsqu’il est exécuté, rejoue les positions enregistrées de manière fluide et rapide.

Si vous considérez ces explications un peu abstraites, la vidéo suivante sera peut-être plus parlante :

Au final, même si cette interface reste dépouillée et souffre parfois d’un peu de lag, elle est facilement utilisable et elle démontre surtout un des gros avantages du back-end Youba : la possibilité d’écrire et d’intégrer au projet le front-end de son choix en très peu de temps. J’invite les bidouilleurs un peu curieux à regarder le code du cœur du front-end (resources/youfo.js) qui ne dépasse pas les 150 lignes.

À partir de là, on peut aussi envisager d’autres front-ends pour un pilotage au clavier, au joystick, à la Wiimote… Les plus motivés pourront décliner le produit en version un poil plus réactive grâce à une réécriture Java ou Qt… Il y a de quoi faire : amusez-vous, faites-vous plaisir.

Dernières recommandations :

  • Youfo nécessite une version de Youba >= 1.4
  • Les deux applications se trouvent sur la page des téléchargements.

Enjoy !

 Une méthode intelligente pour refaire la déco des flips

 2 mars 2009  Projet Arcade  Aucun commentaire
Les décors en hauteur de Gold Wings, cibles d'agressions permanentes...

Misteriddler nous gratifie d’une très belle méthode en DIY pour refaire les décos en plastique qui ont parfois tendance à souffrir dans les flippers.

Les décors en hauteur de Gold Wings, cibles d'agressions permanentes...

Les décors en hauteur de Gold Wings, cibles d'agressions permanentes...

Les miens sont devenus assez ternes avec le temps, faute de lavage avec Mir Express, et certains sont cassés. D’autres sont en fin de vie, comme la « tour de Babel » que l’on peut voir sur la photo (4 étages de plastique tenus par seulement 2 supports), et qui est encore intacte malgré le nombre conséquent de « coups de boule » qu’elle se ramasse à longueur de journée par tous les nigauds comme moi qui bourrinent pour essayer en vain de passer le looping juste derrière (je dois remettre la piste du loop dans l’axe car là il est impossible à passer).

Même si je me vois mal refaire ce type de décors à la main, compte tenu des textures pas forcément évidentes à reproduire et du nombre de pièces plastiques concernées, cette méthode a le mérite d’exister et elle me servira peut-être un jour, qui sait…