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?

7 réflexions au sujet de « Halloween tricks »

  1. Excellent !
    J’aimerais pouvoir le reproduire.
    Avez-vous un schéma plus précis ou un tuto encore plus complet pour m’aider à le réaliser ?
    Merci d’avance

      1. Je dispose effectivement d’une led. Le schéma présenté plus haut est trop compliqué pour moi (nul en électronique). J’ai possibilité d’avoir une webcam. Ce que je ne vois pas c’est comment faire intéragir ces éléments entre eux.
        Je dispose aussi de la carte Piface.

        1. Bon bah juste une petite info j’ai réussi à obtenir le résultat avec une led. J’ai utilisé motion et ses paramètres. voilà =)

          1. OK, c’est génial ! une solution tout en C aurait été de connecter simplement la LED à un GPIO et d’utiliser le code source que nous proposons.

Répondre à Léo Annuler la réponse

Votre adresse e-mail ne sera pas publiée.