Raspberry Pi et domotique

raspberry-ban
Afin d’appareiller nos maisons respectives, nous cherchions une solution domotique abordable.
Après avoir fait le tour du net et des magasins de bricolage, nous nous sommes fixés sur les équipements avec une fréquence de 433Mhz. Ces équipements sont économiques, les protocoles utilisés sont statiques et il est très simple de trouver de quoi communiquer avec.

Le projet

Nous avons profité d’un projet lancé par l’ENSICAEN en partenariat avec Radiospare. Nous souhaitons d’ailleurs les remercier tous les deux pour nous avoir accompagner tant financièrement que techniquement durant ce projet.

La base du projet est la réalisation d’un projet domotique avec Raspberry Pi.

Nous avons choisi de réaliser un petit module à greffer sur les ports du Raspberry Pi afin de pouvoir éteindre et allumer des équipements en RF433 (volets roulants, prises, lumières, etc…).
Une fois ce module réalisé, nous avons développé une interface web afin de pouvoir utiliser et scénariser les équipements.

L’architecture

Nous avons développé notre module à l’aide d’un composant permettant de moduler et démoduler les signaux RF433, le RTX MID 3V.

Afin de capturer les signaux, nous avions besoin d’un système temps réel. La première solution consiste à installer un OS temps réel sur le Raspberry Pi. La seconde consiste à utiliser un micro-contrôleur. Nous sommes partis sur la seconde solution et avons développé sur un PIC18F24k50. Il présente l’avantage d’être petit, économique et de disposer de suffisamment de RAM.

architexture_hard

Les signaux

Les signaux qui permettent de commander les équipements sont statiques. Ceci implique que pour chaque commande allumer et éteindre, le signal émit est identique. La figure ci dessous représente un signal quelconque.

signal

L’objectif de notre module est donc de faire un enregistreur de signal capable de le réémettre. Nous avons remarqué que le signal de commande était réémis plusieurs fois de suite par les émetteurs du commerce. Ceci est dû au fait que le protocole est à sens unique. Il n’y a donc pas de validation (ACK) une fois le signal reçu. Ces espaces vides sont cependant présents sur plusieurs protocoles RF433 que nous avons observé à l’oscilloscope (équipements des marques DIO et Carrefour).

Afin d’acquérir correctement le signal émis à l’intention de ces équipements, nous utilisons l’algorithme suivant :

  1. Lire état (haut/bas)
  2. Si état haut continuer, sinon revenir à 1
  3. Enregistrer le plus longtemps possible
  4. Chercher la plus longue série d’états bas consécutifs
  5. Chercher la plus proche série d’états bas consécutifs de longueur équivalente
  6. Le signal se trouve entre les deux séries d’états bas

Il suffit ensuite d’émettre plusieurs fois ce signal pour allumer ou éteindre un équipement. Cet algorithme a été implémenté en C. L’enregistrement fonctionne sur le module et la recherche du signal (étape 4 à 6) tourne sur le Raspberry Pi.

Le module

Le module se connecte sur les PIN du Raspberry Pi. La communication entre le Raspberry Pi et le PIC18F24k50 est assuré au travers du port série. Pour cela, il a été nécessaire d’utiliser une astuce pour retirer la console du port série d’un Raspberry Pi.
Le module tient dans un boîtier de Raspberry Pi avec une antenne de 8.175 cm de long.
IMG_20141122_172059

Les prochains travaux consisterons à améliorer l’antenne afin d’optimiser la porté en réception afin de permettre l’ajout de nouveaux modules.

Interface Web

Afin de mettre en place l’interface web, nous avons installé un serveur Nginx. La base php et les interfaces ont été développés par Antoine Choquet.

home

equipements

Quand est ce que ça sort

Nous réalisons encore quelques tests avec l’antenne, ce qui peut entraîner quelques changements sur le PCB. En parallèle, nous testons encore un peu le scripts d’installation. Tout ça devrait être prêt dans le courant de décembre, avant noël. Comme toujours, les sources et les schematics seront libres.

Créer une enceinte programable pour Raspberry pi

electro

Dans cet article, nous allons voir comment modifier une enceinte que l’on trouve dans le commerce afin de l’utiliser avec le raspberry pi.

Pour une application, je souhaitais ajouter la voix à mon raspberry et je devais changer l’enceinte de mon réveil. Pour cela, j’ai utilisé une enceinte autoalimentée que l’on peut recharger en USB. Cette solution a deux inconvénients majeurs :

  • L’enceinte grésille lorsqu’elle est alimentée mais qu’aucun son n’est envoyé sur la prise jack
  • On passe notre temps à recharger l’enceinte si elle n’est pas connectée au pi ou alors on occupe un port usb.

La solution serait donc de pouvoir programmer l’allumage et l’extinction de notre enceinte.

Piloter l’enceinte

Afin de rendre l’enceinte pilotable, j’ai choisi d’agir directement sur l’alimentation.
L’idée est d’utiliser le raspberry pi pour alimenter l’enceinte. Afin de pouvoir faire celà, il faut supprimer la batterie de l’enceinte. Si votre enceinte n’a pas de batterie, vous pouvez passer cette étape.

En démontant l’enceinte j’obtiens ce que l’on voit sur l’image suivante :
IMG_20140820_202701

J’ai donc coupé les deux fils reliant la batterie. Je l’ai fait de mainière à pouvoir les ressouder si dans le futur je souhaite réutiliser l’enceinte en mode portable.

Après cela, j’ai remonté l’enceinte et je me suis attaqué à la réalisation d’un cable USB-mini USB comme ceux qui alimentent nos téléphones portables. Choississez un câble assez gros, le soudage n’en sera que plus facile. Il faut maintenant permettre au pi de contrôler cette alimentation. L’alimentation USB est en 5V. Les GPIO du raspberry pi ne sont que en 3V, il va donc falloir faire un petit montage afin d’effectuer cette conversion. Pour cela, j’utilise le composant SFH6206. Voici le schéma :

Screenshot from 2014-08-22 09:48:10

Une fois assemblé, j’obtiens le montage suivant :

IMG_20140821_085943

La programation

Nous allons utiliser les GPIO, pour cela j’ai développé un petit programme en C à l’aide de la librairie bcm2835. Vous pouvez retrouver un exemple d’installation et de compilation dans cet article.

#include <bcm2835.h>
#include <stdio.h>
#include <stdlib.h>
 
#define PIN_ALIM_SPEAKER RPI_GPIO_P1_07
 
int main(int argc, char ** argv) {
   if (!bcm2835_init()) {
        return EXIT_FAILURE;
   }
 
   //On alimente l'enceinte
   bcm2835_gpio_fsel(PIN_ALIM_SPEAKER, BCM2835_GPIO_FSEL_OUTP);
   bcm2835_gpio_write(PIN_ALIM_SPEAKER, HIGH);
 
   //... Jouer un son
 
   //On éteint l'enceinte
   bcm2835_gpio_write(PIN_ALIM_SPEAKER, LOW);
   bcm2835_close();
   return EXIT_SUCCESS;
}

Rendu final

Afin de cacher un peu le montage, j’ai utilisé un vieux boitier de disque dur externe.


OVERSIMPLE : Un réveil avec un raspberry pi par oversimple

Réaliser un lecteur de badge avec rasberry pi (Partie 2)

raspberry-ban

Introduction

La semaine dernière, nous en étions restés à la compilation de la librairie libnfc. Si vous avez besoin de vous rafraîchir la mémoire c’est par ici. Aujourd’hui nous allons voir comment lire un badge tel que les badges d’entrée d’immeuble avec un programme en C qui tournera sur raspberry Pi.

Lecture de l’uid

Tout d’abord, il est important de savoir que seul un numéro de série est lu par beaucoup de lecteurs de cartes pour le contrôle d’accès. Ceci n’est absolument pas sécurisé et il est possible d’acheter des cartes (sur le marché chinois) permettant de copier ces badges en utilisant le programme d’exemple nfc-mfsetuid disponible dans le dossier exemple. D’ailleurs, les serruriers ne font qu’une simple copie de votre badge vers un nouveau avant de le verrouiller en écriture.

Il serait tout a fait possible de réaliser un protocole sécurisé mais pour cela, il faudrait des badges équipés de capacité cryptographique et donc plus chers. Les badge d’entrée les plus fréquemment utilisés sont des badges Mifare qui ne coûtent vraiment pas grand chose : MIFARE 4K NXP blanche haute qualité Par 5000 = 0.90 € unitaire trouvé sur google.

Nous allons faire comme eux et simplement lire l’uid. Nous ne prétendrons cependant pas que ce soit sécurisé. Pour cela allons dans le dossier exemples/ et lançons le programme suivant :

sudo ./nfc-poll

Et voilà vous venez de lire l’UID de votre badge !

Code C

Nous allons maintenant repartir du programme nfc-poll afin de le personnaliser et de le réutiliser dans notre application. Toujours dans le dossier exemple :

mkdir badgeReader/utils/
cp nfc-poll.c badgeReader/badgeReader.c
cp ../utils/nfc-utils.h examples/badgeReader/utils/
cp ../utils/nfc-utils.c examples/badgeReader/utils/
cd badgeReader/
gcc badgeReader.c utils/nfc-utils.c -lnfc -o myBadgeReader.o
sudo ./myBadgeReader

Félicitation, vous venez de compiler votre première application avec libnfc. Je vous conseille de garder ce squelette de coté, il constitue une bonne base pour commencer avec le NFC.

Vérifier l’UID

Bien, pour l’instant, nous ne faisions que d’afficher l’UID en réutilisant les programmes déjà présents. nous allons maintenant le récupérer et le comparer afin de vérifier si la personne est autorisée à entrer ou non.

Copier le squelette précédemment construit et remplacer le fichier badgeReader.c par celui écrit ci dessous :

/**
 * @file badgeReader.c
 * @brief read a badge and print a message if the badge is the one attended
 */
 
#include <err.h>
#include <signal.h>
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
 
#include <nfc/nfc.h>
#include <nfc/nfc-types.h>
 
#include "utils/nfc-utils.h"
 
static nfc_device *pnd = NULL;
 
int main(int argc, const char *argv[])
{
	const unsigned char referenceUID[7] ={0x04, 0x3c,  0x76,  0x7a,  0xa6,  0x27,  0x80};
	const unsigned char referenceUIDsz = 7;	
 
	const unsigned char uiPollNr = 20;
	const unsigned char uiPeriod = 2;
 
	/* Defines the modulation types
	 * for the mifare types, only the type A is requested */
	const nfc_modulation nmModulations[1] = {
		{ .nmt = NMT_ISO14443A, .nbr = NBR_106 },
	};
 
	int i;
	const size_t szModulations = 1;
 
	nfc_target nt;
	int res = 0;
 
	nfc_context *context;
	nfc_init(&context);
 
	/* We open the pn53x */
	pnd = nfc_open(context, NULL);
 
	if (pnd == NULL) {
		ERR("%s", "Unable to open NFC device.");
		exit(EXIT_FAILURE);
	}
 
	if (nfc_initiator_init(pnd) < 0) {
		nfc_perror(pnd, "nfc_initiator_init");
		exit(EXIT_FAILURE);
	}
 
	if ((res = nfc_initiator_poll_target(pnd, nmModulations, szModulations, uiPollNr, uiPeriod, &nt))  < 0) {
		nfc_perror(pnd, "nfc_initiator_poll_target");
		nfc_close(pnd);
		nfc_exit(context);
		exit(EXIT_FAILURE);
	}
 
	if (res > 0) {
		printf("Read UID     : ");
		print_hex(nt.nti.nai.abtUid, nt.nti.nai.szUidLen);
		printf("Expected UID : ");
		print_hex(referenceUID, referenceUIDsz);
 
	} else {
		printf("No target found.\n");
	}
	nfc_close(pnd);
	nfc_exit(context);
	exit(EXIT_SUCCESS);
}

Vous pouvez maintenant comparer vos deux UID dans un programme.

Conclusion

Pourquoi ne pas ajouter un module comme celui ci à votre raspberry pi et continuer les développement vers quelques chose de plus sécurisé avec l’ajout d’un code PIN par exemple.

It’s oversimple, isn’t it?

Réaliser un lecteur de badge avec rasberry pi (Partie 1)

raspberry-ban

Introduction

Un article en deux parties.Une première cette semaine pour vous expliquer comment installer la librairie sur votre raspberry pi. Le prochain article décrira comment réaliser un programme en C pour lire un badge de type badge d’entrée des immeubles.

La librairie libnfc

La librairie libnfc est une librairie dédiée à la communication en NFC. Cette librairie est publieé sous licence LGPL (libre de droit pour les applications libres ou commerciales).

Celle-ci fonctionne avec un hardware spécifique, on peut trouver la liste sur le wiki de libnfc.

Pour ma part, j’ai un dongle usb équipé d’un PN533 (fabriqué par NXP). La photo est ci dessous :

dongle_pn533.jpg

Télécharger la librairie

Les liens du wiki officiel sont brisés mais une petite recherche google nous permet de retrouver la release. Pour les projets sur le Pi, privilégiez les versions packagées aux versions développeurs.

wget https://libnfc.googlecode.com/files/libnfc-1.7.0-rc3.tar.gz
tar -xvzf libnfc-1.7.0-rc3.tar.gz 
cd libnfc-1.7.0-rc3/

Configuration

Si vous souhaitez configurer la librairie pour un pn532 en UART comme ceux de chez Adafruit il va falloir commencer par libérer l’UART du pi comme indiqué dans cette article :

Puis une fois l’UART libéré, il va falloir copier le fichier de configuration comme suit :

sudo mkdir -p /etc/nfc/devices.d
sudo cp contrib/libnfc/pn532_uart_on_rpi.conf.sample /etc/nfc/devices.d/pn532_uart_on_rpi.conf

Editez ensuite le fichier suivant :

sudo nano /etc/nfc/devices.d/pn532_uart_on_rpi.conf

Et modifiez la ligne suivante à la fin du fichier

allow_intrusive_scan = true

Compilation

Enfin nous pouvons maintenant compiler les sources :

./configure --with-drivers=pn532_uart --sysconfdir=/etc --prefix=/usr
autoreconf -vis
make clean
sudo make install

Et pour tester :

cd utils/
sudo ./nfc-scan-devices

Et vous devriez voir apparaître quelque chose comme ça :

1 NFC device(s) found:
- NXP / PN533:
    pn53x_usb:002:003

Conclusion

En attendant l’article de la semaine prochaine (il est déjà écrit, il ne reste qu’à le mettre en pa