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

Wake me up !

raspberry-ban

Aujourd’hui, ajout de la fonctionnalité réveil matin à notre Raspberry pi. Pour réaliser tout ça, nous allons greffer à notre raspberry pi : un bouton champignon.

Réalisation du bouton champignon

Pour éteindre notre réveil, nous allons hacker la petite veilleuse pour enfant.

Eclairage-technique-Inspire-GELA-Veilleuse-LED-Vert-11270-444

Vous pouvez la trouvez en cliquant ici.

On commence par démonter la lampe et désolidariser la led de l’interrupteur poussoir. Nous voulons faire ressortir la masse, une entrée pour allumer la led et une sortie pour avoir l’état de l’interrupteur (ouvert ou fermé).

IMG_6027

IMG_6047

IMG_6049

Enfin pour le haut parleur, n’importe lequel peut faire l’affaire. En prévoir un qui soit tout de même auto alimenté, ou bien utiliser comme nous un ampli audio 5V que l’on a relié à l’alimentation du Raspberry pi.
Attention dans le cas où l’ampli audio est alimenté via le Raspberry pi, ne pas oublier de prendre une alimentation plus forte qu’un simple chargeur de téléphone.
Screenshot from 2013-07-24 20:02:20

Ce qui nous donne :

IMG_20130726_194125

Nous codons la détection en C. Pour cela nous réutilisons la même librairie que pour l’alarme de maison : Alarme de maison avec un raspberry pi
La fonction suivante nous permet d’allumer ou d’éteindre la led de notre lampe :

void detectInput(void) {
   uint8_t value;
   uint8_t refValue;
 
   refValue = bcm2835_gpio_lev(PIN_SENSOR);
 
   do {
      // lecture du niveau d'entre©e
      value = bcm2835_gpio_lev(PIN_SENSOR);
      delay(400);
   } while(refValue == value);
 
   bcm2835_gpio_write(PIN_ACTOR, HIGH);
}

Enfin pour ce qui est de jouer de la musique nous allons utiliser le programme aplay qui est présent par défaut.
Le fichier source est disponible en annexe.

Il nous suffit alors de lancer le programme à l’aide d’une tâche cron à l’heure du réveil.

Sources et Bibliographie

It’s Oversimple, isn’t it?

Attaque sur carte sans contact

Un petit retour sur le workshop de la Nuit du Hack.

La démonstration principale de ce workshop était une attaque sur les cartes sans contact. Celles-ci proposent de payer en sans contact à une distance d’une dizaine de centimètre du lecteur. Ce paiement ne nécessite pas de saisir son code PIN. Il est cependant limité à des transactions d’un montant maximal de 20€ et à 4 transactions consécutives. Après il faut passer en mode contact pour réaliser une transaction.

Description de l’attaque

L’idée est de réaliser un proxy permettant de faire une transaction à distance.

explain

Le téléphone est un téléphone NFC qui permet de réaliser des transactions en sans contact. Celui-ci est relié par un réseau, par exemple un réseau internet, à un lecteur de carte sans contact. Ce lecteur dans le schéma est représenté à droite à coté du personnage en costume. Il est relié à un ordinateur afin de pouvoir être accessible depuis un réseau.

Nous aurions aussi pu utiliser un autre téléphone NFC à la place du couple PC – lecteur sans contact. Cependant je n’avais à ma disposition qu’un seul téléphone NFC.

L’attaque consiste à réaliser un proxy passif afin de réaliser un paiement à l’aide d’une carte qui ne se trouve pas à proximité du lecteur. Puisque la technologie est sans contact, cela peut être réalisé à l’insu de la cible.

Réalisation

Afin de réaliser cette attaque, un téléphone Nexus S a été utilisé. Ce téléphone possède une puce NFC et permet l’installation de l’application simply tap avec une cyanogen mod 9.1. Cette application permet d’avoir accès à l’antenne NFC du téléphone depuis une application android. Le but premier est de réaliser des services de paiement en cloud.

Dans notre cas, au lieu d’interroger un cloud, nous interrogeons un lecteur distant afin de dialoguer directement avec une carte sans contact.

Démonstration :


Attaque par proxy par oversimple

Comment s’en protéger

Pour s’en protéger, c’est assez simple il suffit de mettre sa carte dans un étui en fer. Il existe des portes feuilles blindés qui font très bien l’affaire.

Bibliographie

SimplyTapp NFC Payment System Debuts with CyanogenMod 9.1
emulating pki smart card with cm9.1
NFC Proxy

Alarme de maison avec un raspberry pi

raspberry-ban

J’ai un ami qui souhaite vérifier que personne n’entre chez lui quand il n’est pas là. Ceci peut être intéressant pour Dexter mais aussi en cas de propriétaire invasif. Afin de contrôler les allers et venues dans son appartement, nous avons eu l’idée de prendre en photo avec une webcam toutes les personnes qui passent la porte. Les photos pourront ensuite être envoyées par mail ou bien sur une interface web.

Mise en place d’un système de sécurité

Un système de sécurité est composé de capteurs. L’ensemble des capteurs permet de détecter une présence. On va retrouver des capteurs sur les portes et fenêtres qui permettent de savoir si celles ci sont ouvertes. On peut aussi trouver des capteurs de mouvement. Dans notre cas, nous souhaitons utiliser un capteur permettant de détecter l’ouverture d’une porte. Celui ci a été récupéré dans le vieux carton d’un projet de technologie réalisé en 4ième.

capteur

Ce capteur va alors être relié à un GPIO du raspberry pi. Il faudra ensuite prendre une photographie en direction de la porte d’entrée sur laquelle le capteur sera placé. On aurait tout aussi bien pu activer un buzzer.

Partie hardware

le capteur fonctionne avec un commun et une sortie normalement ouvert et normalement fermé. L’idée est de relier ce capteur à un GPIO du raspberry pi afin que l’on détecte sur le GPIO :

  • Un état haut (3.3V) si la porte est fermé
  • Un état bas (0V) si la porte est ouverte

Nous obtenons le câblage suivant :

cablage

Afin de s’assurer que la sortie est à l’état bas lorsque la porte est ouverte nous utiliserons une résistance de pulldown.
pour réaliser ce montage nous utilisons un connecteur au pas de 2.54 ainsi qu’un petit domino et nous obtenons le montage suivant, qui se fixe simplement sur le raspberry pi :

pontRasp

Il faut maintenant détecter le niveau de la pin GPIO22. Pour cela nous allons utiliser, une librairie C conçue pour piloter nos GPIO.

Librairie C pour le BCM 2835

La librairie que nous utilisons est disponible ici : librairie

Sur le raspberry pi, ouvrez un shell :

$ wget http://www.open.com.au/mikem/bcm2835/bcm2835-1.17.tar.gz
$ tar zxvf bcm2835-1.17.tar.gz
$ cd bcm2835-1.17
$ ./configure
$ make
$ sudo make check
$ sudo make install

La librairie est maintenant installée.
Les noms des GPIO sont ceux décrit en orange dans l’image ci dessus. Il sont nommés de RPI_GPIO_P1_01 à RPI_GPIO_P1_26. Et ils correspondent aux 26 broches de sorties. Cependant, ils ne correspondent pas aux sorties que vous pouvez utiliser via le système de fichier. Le GPIO22 que nous allons utiliser est ainsi appelé RPI_GPIO_P1_15.

Sur le site de la librairie nous trouvons directement un exemple que nous allons réutiliser dans notre projet. Si vous souhaitez repartir de la source originale, elle se trouve ici : source
Pour détecter le niveau de sortie du GPIO22, nous utilisons le code C suivant:

//input.c
#include <bcm2835.h>
#include <stdio.h>
// Input sur le GPIO22 qui est nommé 15 dans le système de la librairie
#define PIN RPI_GPIO_P1_15
 
int main(int argc, char ** argv) {
    if (!bcm2835_init()) {
        return 1;
   }
    // Fixe le GPIO en entrée
    bcm2835_gpio_fsel(PIN, BCM2835_GPIO_FSEL_INPT);
    //  avec une résistance de pull down
    bcm2835_gpio_set_pud(PIN, BCM2835_GPIO_PUD_DOWN);
 
    while (1) {
        // lecture du niveau d'entrée
        uint8_t value = bcm2835_gpio_lev(PIN);
        printf("lecture GPIO22: %d\n", value);
 
        // attendre 2s
        delay(2000);
    }
    //Un brin de toilette
    bcm2835_close();
    return 0;
}

Compilons et lançons le programme et amusons nous à déplacer le capteur (équivalent à ouvrir et fermer la porte) :

$ gcc input.c -l rt -l bcm2835 -o input
$ sudo ./input
lecture GPIO22: 1
lecture GPIO22: 1
lecture GPIO22: 0
lecture GPIO22: 0
lecture GPIO22: 1

Photographie avec la webcam

Afin de photographier l’entrée, nous allons réutiliser la librairie openCV. Celle ci avez déjà été utilisé à Halloween pour réaliser un capteur de mouvement avec une webcam. Je vous invite à lire l’article suivant pour l’installation et la programmation : Halloween project

Pour ce qui est de l’installation, elle est faite directement depuis les dépôts.

$ sudo apt-get install libcv-dev libcvaux-dev libhighgui-dev

Le code complet est disponible en annexe.

Envoi par mail et interface graphique

L’envoi par mail et l’interface graphique sont codés en php. Les appels entre les deux langages se font soit via la commande system, soit via des pipes nommées.

Et l’interface web donne:

screenShot

Conclusion

Vous pouvez remplacer le capteur par un détecteur de mouvement. N’hésitez pas à nous contacter si vous souhaitez en savoir d’avantage ou avez d’autres idées saugrenues.

It’s oversimple isn’t it?

Contourner les caméras de sécurité


Je ne sais pas vous, mais moi, toutes ces caméras qui surveillent mes moindres faits et gestes ça m’ennuie un peu.

Alors certes, c’est certainement pour le bien des citoyens que de les filmer en permanence, mais ça reste un peu intrusif.

Bien sur, je pourrais trouver un hack sympa à faire pour ne plus être filmé en permanence. Peut être même que ce hack concernerait tous les capteurs CCD et donc aussi les radars automatiques et autres webcams qui enregistrent en temps réel.

Let’s investigate (oui maintenant on se la fait à l’américaine).

Etude d’un capteur CCD

On apprend sur Wikipedia qu’il a été inventé par George E. Smith et Willard Boyle , et que ça leur a valu le prix nobel mais sur tout d’après wikipédia : « Un capteur photographique est un composant électronique photosensible servant à convertir un rayonnement électromagnétique (UV, visible ou IR) en un signal électrique analogique. »

On y apprend ensuite que la matrice RGB qui numérise le signal est constituée de photodiodes sensibles au rouge / vert et bleu et que c’est le logiciel qui recalcule les couleurs en fonction de l’intensité enregistrée par chaque photodiode.

Des photodiodes donc…

Les photodiodes ont une courbe de sensibilité centrée sur une longueur d’onde particulière. Ce qui m’intéresse c’est la répartition de cette sensibilité. En effet si cette sensibilité dépasse le domaine du visible et là je pense aux capteurs rouges qui sont proches de l’infra rouge, alors on pourrait imaginer éblouir la caméra sans que cela ne soit visible dans le monde réel.

Recherchons la courbe de sensibilité des photodiodes bleus et rouges, qui pourrait être sensible aux ultra violets et aux infrarouges.
On a, toujours sur Wikipédia, l’information suivante :

Donc il n’est pas sensible qu’au spectre du visible qui s’étend de 400 à 700 nm (0.4 à 0.7 sur le diagramme). Toujours d’après ce même diagramme on peut imaginer que si on tape dans les infrarouges, le capteur rouge est largement éclairé. On pourrait donc l’éblouir et faire une attaque de type DOS dessus.

Essais

Un diode infrarouge peut être récupérée dans n’importe quelle télécommande. On va donc faire un petit essai avec plusieurs capteurs, à commencer par la webcam du pc, le téléphone portable et un appareil photo professionnel. Pour cela j’utilise une diode récupérée sur une vieille télécommande de freebox. J’utilise un des GPIO de mon raspberry pour l’alimenter. Cela permet de l’allumer ou de l’éteindre simplement.

Les résultats parlent d’eux même, le capteur est sensible aux infrarouges. Des résultats similaires on était observé avec l’appareil photo et la webcam.

Cas de la plaque d’immatriculation

Ajoutons une seconde led à notre montage que l’on va placer autour d’un numéro afin d’évaluer les capacités d’obfuscation :

Allumons notre montage :

Conclusion

Il ne s’agit là que de petite diodes. On peut facilement imaginer fabriquer un montage relié à la batterie du véhicule avec des diodes pour contourner les radars (fixes ou mobiles). On peut aussi imaginer dissimuler un visage aux caméras avec une casquette équipée de leds alimentées par une pile 9V.

It’s Oversimple isn’t it?

Halloween tricks

 

 

 

Il faut dire qu’on aime la citrouille. Et puis on vient de recevoir nos raspeberry pi.  En y regardant de plus prêt, on se rend rapidement compte qu’il faut faire quelque chose pour Halloween.

L’idée originale est donc de faire une lampe en citrouille qui s’active par la présence.

Prise en main du Raspberry pi

La première chose à faire est de voir si tout fonctionne. On va utiliser un Debian embarqué tel qu’il est proposé sur le site du raspberry pi. Pour notre projet, nous avons besoin d’allumer une lampe.
Les GPIO sont des broches d’entrée sortie dont on peut lire le niveau électrique (haut ou bas) et sur lequel on peut imposer un niveau de sortie (haut ou bas). Le niveau logique haut est une tension de 3.3V et le bas une tension de 0V.

Le mappage des GPIO est indiqué sur l’image suivante. Remarquez le petit p1 sur votre board et sur le schéma qui permettent de s’orienter.

Nous allons nous en servir en sortie pour activer une led dans un premier temps. Voici une photographie du montage :


Pour ce faire il faut définir la GPIO et indiquer le mode output :

echo "17" > /sys/class/gpio/export
echo "out" > /sys/class/gpio/gpio17/direction

Pour information: les GPIO fonctionnent sur les microcontroleurs (comme l’ARM du Raspberry pi) en three-state logic : Wikipédia

Il suffit maintenant de mettre à l’état haut le GPIO associé avec la commande suivante :

echo "1" > /sys/class/gpio/gpio17/value

Pour le mettre à l’état bas, mettre la valeur 0.

Pour le détecteur de mouvement en pratique il aurait été bon de prendre un détecteur infrarouge. Mais bien que terriblement efficace ce n’est pas aussi amusant que d’utiliser une webcam et de faire un peu de traitement d’image.

Conception du détecteur de mouvement

En ce qui concerne le détecteur de mouvement, nous avons utilisé une webcam ainsi que la librairie OpenCV. Voici un extrait de notre main simplifié :

int main(int argc, char **argv) {
 
	// Initialisation de notre lampe qui se trouve connecté au gpio 17
	// (voir ci-dessus)
 
	// Image
	IplImage *image1=NULL;
	IplImage *image2=NULL;
	IplImage *subImage=NULL;
 
	// Capture vidéo
	CvCapture *capture;
 
	// Ouvrir le flux vidéo,  mettre en paramètre le device de la cam (pour X = /dev/videoX)
	capture = cvCreateCameraCapture(atoi(argv[1]));
 
	//Configuration de la capture par défaut, donc la taille d'une image que l'on va récupérer. 640*480
	cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, 640);
	cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, 480);
	cvSetCaptureProperty(capture, CV_CAP_PROP_BRIGHTNESS, 0.65);
 
	// Vérifier si l'ouverture du flux est ok
	if (!capture) {
		printf("Ouverture du flux vidéo impossible !\n");
		return 1;
	}
 
	printf("Enjoy !");
 
	// On allume notre lampe 2 fois avec une pause de 1 seconde 
 
	while(1) {
		// On récupère une image 
		image1 = cvQueryFrame(capture);
 
		// On attend 50 milisecondes
		cvWaitKey(50);
 
		// On sauvegarde notre image 1.
		cvSaveImage("buffer1.jpg",image1,0);
 
		// On récupère une image 2
		image2 = cvQueryFrame(capture);
 
		// On sauvegarde notre image 2
		cvSaveImage("buffer2.jpg",image2,0);
 
		// On recherche les 2 images
		image1 = cvLoadImage("buffer1.jpg", CV_LOAD_IMAGE_GRAYSCALE);
		image2 = cvLoadImage("buffer2.jpg", CV_LOAD_IMAGE_GRAYSCALE);
 
		// On soustrait les 2 images une à une afin d'avoir une différence.
		subImage = substract(image1, image2);
 
		// On calcul le nombre de pixel différents
		int trigger = count(subImage);
 
		// On compare la différence avec notre TRIGGER de test.
		if(trigger > TRIGGER) {	
			// Si plus de pixel modifié par rapport a notre TRIGGER, 
			// On allume la lampe pendant 10 secondes
		}
	}
 
	// On Libère notre webcam.
	cvReleaseCapture(&capture);
 
	return 0;
}

L’ensemble du code est présent en archive.

Assemblage

Une fois le programme lancé, on lui a apporté quelques modifications afin de changer l’état d’un GPIO en 5V. Pour allumer notre lampe allimentée sur le secteur nous utiliserons un relais activable en 5V.
Cependant, les GPIO du raspberry pi ne peuvent fournir que 3.3V. Pour pouvoir activer notre relais il faut amplifier le signal. Pour cela nous avons utilisé la sortie 5V du raspberry pi et un ampli audio (LM386) avec un montage non inverseur.

L’ensemble des pièces aillant été récupéré ici et là. Ci-dessous le schéma du montage :

Résultat final


OVERSIMPLE : Halloween détecteur de mouvement par oversimple

Source

Site officiel d’OpenCV

GPIO Raspberry Pi

Codes : complete source code
It’s Oversimple isn’t it?

Halloween Tricks [English Version]

 

 

 

We like pumpkin and for halloween we decide to create with our raspberry pi a motion sensor.

How it’s works ?

The idea is simple, when somebody is in the piece, the lamp is putted on.

Discover Raspberry pi

First step, we install a debian on ourraspberry pi.

Second step, we need to start a lamp with the gpio of the raspberry pi.
GPIO are input output spindle, we can have a high voltage (3.3 V) or low voltage ( 0V ).

We can see on the following picture, how to are the GPIO dispatched.

The first thing we do was to put on a LED. This was done by simply connecting a LED to the GPIO 17 and a resistor in serie.


We define the gpio 17 and we use this as an output :

echo "17" /sys/class/gpio/export
echo "out" /sys/class/gpio/gpio17/direction

And to enable the led, we put the voltage high :

echo "1" /sys/class/gpio/gpio17/value

Note : to put off the led we simply replace « 1 » by « 0 »

Create a motion sensor with a webcam

In practice, we could use a infrared motion sensor. However we only  have a webcam, and it’s more challenging with a webcam.

The code is available in the archive.

int main(int argc, char **argv) {
 
	// Initialization GPIO 17
 
	// Image
	IplImage *image1=NULL;
	IplImage *image2=NULL;
	IplImage *subImage=NULL;
 
	// Capture movie
	CvCapture *capture;
 
	// Open the webcam with the number of the device (/dev/videoX for X the number)
	capture = cvCreateCameraCapture(atoi(argv[1]));
 
	//Configure the resolution for the webcam
	cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, 640);
	cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, 480);
	cvSetCaptureProperty(capture, CV_CAP_PROP_BRIGHTNESS, 0.65);
 
	// Check if capture is ok
	if (!capture) {
		printf("Ouverture du flux vidéo impossible !\n");
		return 1;
	}
 
	printf("Enjoy !");
 
	// We start our lamp 2 time for check and give the signal
 
	while(1) {
		// Screen first picture
		image1 = cvQueryFrame(capture);
 
		// Waiting 50 milisecondes
		cvWaitKey(50);
 
		// Save image 1
		cvSaveImage("buffer1.jpg",image1,0);
 
		// Screen second picture
		image2 = cvQueryFrame(capture);
 
		// Save image2
		cvSaveImage("buffer2.jpg",image2,0);
 
		// We save both picture
		image1 = cvLoadImage("buffer1.jpg", CV_LOAD_IMAGE_GRAYSCALE);
		image2 = cvLoadImage("buffer2.jpg", CV_LOAD_IMAGE_GRAYSCALE);
 
		// We substract image1 and image2
		subImage = substract(image1, image2);
 
		// We count the number pixel difference of the image 1 and image 2.
		int trigger = count(subImage);
 
		// We compare with our TRIGGER, if we detect mouvement
		if(trigger &gt; TRIGGER) {	
			// if more pixel modify we start the lamp
		}
	}
 
	// Free capture
	cvReleaseCapture(&amp;capture);
 
	return 0;
}

Assembly

Ok, now the program works but we have a problem with GPIO . to put on our lamp we need 5V. For this reason we use a relay in 5V.

However, the raspberry pi ‘GPIO can only provide 3.3V. We need to amplify the signal.

We use the output 5V of the raspberry and an audio amplify (LM386) in non inverting scheme.

We can see the assembly :

Final result


OVERSIMPLE : Halloween détecteur de mouvement par oversimple

Source

Site officiel d’OpenCV

GPIO Raspberry Pi

Codes : complete source code

It’s Oversimple isn’t it?