divers – OVERSIMPLE

Open data, les calendriers

Dans cet article nous verrons comment récupérer les données d’un google agenda afin de le rendre exploitable par une application android ou java. Je l’utilise moi même pour le système d’intelligence artificiel qui contrôle ma maison. Je peux ainsi prévoir mes prochains rendez vous et connaitre mes rendez vous de la journée lorsque je me lève. Afin de réaliser le parsing des données, j’utilise la librairie iCal4j qui est assez bien documenté et pour lequel le net regorge d’exemple.

Le format iCalendar

Le format est iCal est un format qui permet de représenter les agendas. Il s’agit d’un format normalisé. La page Wikipedia à ce sujet est assez bien réalisée et je vous laisse le soin de la visualiser.

Google propose d’exporter vos agendas dans ce format. Vous ne devriez pas rencontrez de difficulté si vous suivez les instructions des services de google à cette adresse. Attention à bien lire jusqu’au bout et à partager votre agenda (le rendre public) pour pouvoir accèder aux données.

Vous devez maintenant avoir un lien iCal qui ressemble à celui ci : « https://www.google.com/calendar/ical/mon.compte%40gmail.com/public/basic.ics »

Quelques exemples

Si vous avez pris le temps de lire la page Wikipedia, vous connaissez maintenant les différents composants que l’ont peux récupérer. Si vous ne l’avez pas encore fait je vous invite à le faire, c’est très rapide et ceci vous permettra de comprendre comment fonctionne le standard.

J’aimerai récupérer mon prochain rendez vous afin de l’afficher par exemple. Si celui ci a lieu dans plus de 7 jours, alors je n’en prends pas compte et indique à l’utilisateur qu’il n’a pas de rendez vous prévu dans les 7 prochains jours.

Pour cela il est nécessaire de :

Récupérer un flux vers l’url de mon google agenda au format iCal
Parser ce flux de données
Filtrer les données pour récupérer les VEVENTs qui ont lieu dans les 7 prochains jours
Afficher le premier VEVENT ou bien un message si il n’y a pas de rendez vous dans les 7 prochains jours

ce qui donne le code correspondant :

//1 Récupérer le flux de icalendar à partir de mon google agenda
URL googleCalendar = new URL("https://www.google.com/calendar/ical/mon.compte%40gmail.com/public/basic.ics");
BufferedReader in = new BufferedReader(new InputStreamReader(googleCalendar.openStream()));
 
//2 Parser le flux de données
CalendarBuilder builder = new CalendarBuilder();
Calendar calendar = builder.build(in);
 
//3 Filtrer les données pour récupérer les VEVENTs qui ont lieu dans les 7 prochains jours
Period period = new Period(new DateTime(today.getTime()), new Dur(7, 0, 0, 0));
Filter filter = new Filter(new PeriodRule(period));
Collection<?> eventsToday = filter.filter(calendar.getComponents(Component.VEVENT));
 
//4 Afficher le premier VEVENT ou bien un message si il n'y a pas de rendez vous dans les 7 prochains jours
Iterator<?> i = eventsToday.iterator();
if (!i.hasNext()) {
   System.out.println("Pas de rendez vous dans les 7 prochains jours");
} else {
   Component component = (Component) i.next();
 
   DateTime dateStart = new DateTime(component.getProperty("DTSTART").getValue());
   //DateTime dateEnd = new DateTime(component.getProperty("DTEND").getValue());
   String description = component.getProperty("DESCRIPTION").getValue();
   String location = component.getProperty("LOCATION").getValue();
   String name = component.getProperty("SUMMARY").getValue();
DateFormat formater = new SimpleDateFormat("dd MMMM yyyy 'à' hh 'heure et' mm 'minutes'",new Locale("FR", "fr"));
 
sentence = "Vous avez rendez-vous " + name + " le " + formater.format(dateStart) + ".";
if(null != location && !location.isEmpty()) {
   sentence = sentence + " Il se tiendra à " + location + ".";
}
 
if(null != description && !description.isEmpty()) {
   sentence = sentence + " La description asocié est " + description + ".";
}
 
System.out.println(sentence);

Afin d’obtenir d’avantage d’exemples, je vous invite à parcourir la page du wiki de iCal4j : http://wiki.modularity.net.au/ical4j/index.php?title=Examples
Vous y trouverez des exemples pour ajouter / récupérer des VEVENT, VCARD, générer un iCal etc…

Open data, parsing XML

On entend beaucoup parler de l’open data. Ce concept qui veut ouvrir les données afin que tout le monde puisse les réutiliser est en théorie une grande idée qui permet au plus créatif de réaliser l’application de leur rêve.

On voit fleurir un peu partout des hackathons qui proposent d’utiliser ces données et lorsqu’il s’agit de s’en servir, les développeurs déchantent assez rapidement. Le principe de l’open data consiste bien souvent à balancer les données dans un format difficile à utiliser.

Pour cet article, nous allons réaliser un convertisseur de devises à l’aide de données accessibles publiquement. Vous pouvez trouver le convertisseur sur le playstore à cette adresse
Vous pouvez aussi accèder directement aux sources sur github

Trouver les données

Sur internet les sites qui proposent les taux de change en temps réels sont assez nombreux. Il s’agit même d’un véritable business utilisé par les traders. Pour notre convertisseur, nous souhaitons avoir une source fiable et gratuite. Le format est aussi asez important, il faut si possible utiliser un format courant comme le XML ou le json. Afin de s’assurer de la fiabilité des données, il n’y a je pense qu’une seule chose à faire, avoir une source de confiance. Afin de trouver des données publiques, je commence toujours par lister l’ensemble des organismes publiques qui me viennent à l’idée et qui pourraient mettre cette donnée en ligne.

Dans notre cas nous cherchons les taux de change, j’ai donc choisi d’orienter mes recherches vers :

Les banques centrales
Les banques d’état
Tout les services de l’état qui pourraient avoir à faire de prés ou de loin à de la monnaie (ministère des affaires étrangères, etc)

A cette liste, je conseille d’ajouter systèmatiquement les organismes de normalisation tel que l’ISO ou l’ANSI. Ces organismes regorgent de données publiques qui sont dans des formats très faciles à gérer (xml ou csv).

Utiliser la donnée

Après ces recherches je suis rapidement tombé sur le site de la banque centrale européenne qui offre un accès en XML aux taux de changede la journée.

La source est fiable et offre en plus de cela des exemples pour les développeurs en php. Je souhaite réaliser une application android, mais les exemples sont souvent un gage de qualité (ou laisse penser que les données on au moins étaient testé).

Voici le fichier XML proposé :

<gesmes:Envelope>
<gesmes:subject>Reference rates</gesmes:subject>
<gesmes:Sender><gesmes:name>European Central Bank</gesmes:name></gesmes:Sender>
<Cube>
<Cube time="2014-08-07">
<Cube currency="USD" rate="1.3368"/>
<Cube currency="JPY" rate="136.76"/>
<Cube currency="BGN" rate="1.9558"/>
<Cube currency="CZK" rate="27.853"/>
...
</Cube>
</Cube>
</gesmes:Envelope>

La banque centrale européenne propose les taux de change par rapport à l’Euro. Afin d’obtenir les autres taux de change, nous réalisons une simple règle de trois.

Pour parser le xml, j’utilise la librairie jdom. Le code proposé sur le github est assez parlant, si vous rencontrez des problèmes n’hésitez pas à poster un commentaire. Le problème suivant est que nous souhaiterions avoir le nom de la monnaie plutôt que le symbole. Pour cela nous retournons à l’étape précèdente et récupérons une autre source.

La source proviens de l’iso (http://www.currency-iso.org/dam/downloads/table_a1.xml), de cette manière je récupére les données suivantes :

<ISO_4217 Pblshd="2014-03-28">
<CcyTbl>
<CcyNtry>
<CtryNm>AFGHANISTAN</CtryNm>
<CcyNm>Afghani</CcyNm>
<Ccy>AFN</Ccy>
<CcyNbr>971</CcyNbr>
<CcyMnrUnts>2</CcyMnrUnts>
</CcyNtry>
<CcyNtry>
<CtryNm>ÅLAND ISLANDS</CtryNm>
<CcyNm>Euro</CcyNm>
<Ccy>EUR</Ccy>
<CcyNbr>978</CcyNbr>
<CcyMnrUnts>2</CcyMnrUnts>
</CcyNtry>
<CcyNtry>
<CtryNm>ALBANIA</CtryNm>
<CcyNm>Lek</CcyNm>
<Ccy>ALL</Ccy>
<CcyNbr>008</CcyNbr>
<CcyMnrUnts>2</CcyMnrUnts>
</CcyNtry>
...

Afin de réaliser l’application j’aurai souhaité avoir un fichier xml comme celui ci :

<?xml version="1.0" encoding="UTF-8"?>
<CurrenciesCode>
...
  <Currency code="CNY">Yuan Renminbi</Currency>
  <Currency code="JPY">Yen</Currency>
  <Currency code="XBD">Bond Markets Unit European Unit of Account 17 (E.U.A.-17)</Currency>
  <Currency code="UGX">Uganda Shilling</Currency>
  <Currency code="RON">New Romanian Leu</Currency>
  <Currency code="UYI">Uruguay Peso en Unidades Indexadas (URUIURUI)</Currency>
  <Currency code="TTD">Trinidad and Tobago Dollar</Currency>
  <Currency code="SHP">Saint Helena Pound</Currency>
  <Currency code="MOP">Pataca</Currency>
...

Pour ce faire, j’ai donc choisi de réaliser une conversion des données et d’inclure directement le fichier dans mon projet android. Je ne pense pas que les devises changent en permanence de nom et dans le cas de l’apparition d’une nouvelle devise, il suffira de mettre à jour l’application avec un fichier mis à jour. Si vous souhaitez récupérer ce fichier, il est présent dans les sources github dans le fichier assets.

Conclusion

Cet article reprend les grand principes pour travailler avec des données publiques. La méthodologie est celle que j’utilise, le choix des données est très important, je vous recommande de toujours choisir des grands organismes qui souhaitent garder à jour les données (et qui on un interêt à le faire).
N’hésitez pas lorsque cela est nécessaire à retraiter la donnée. Ce traitement permet d’alléger votre application mais ne peut se faire que sur les données statiques.

It’s oversimple isn’t it?

Créer une enceinte programable pour Raspberry pi

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 :

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 :

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

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

Nuit du Hack 2k13

Un petit bilan de la nuit du hack.

Un petit retour sur la Nuit du hack qui vient de se passer. Cette année les confs étaient essentielement en anglais. On peut y voir une volontée de s’ouvrir de plus en plus vers l’étranger.

Le thème du SE est revenu assez fréquement. On a eu comme toujours le droit à notre lot de surprises. Nous avons une petite préference pour les techniques roumaines de fraudes bancaires sur internet.

L’idée est simple, convertir des euro en leu roumain (l’argent roumain) et utiliser les arrondis du troisième digit pour se retouver avec un arrondi supérieur en notre faveur. Ce qui est amusant c’est de voir comment avec ingéniosité il a automatisé les vérifications du code secret qui valide les transactions. Ses automates valent le détour.

Sinon, Julien a présenté un workshop sur le NFC. Le workshop s’est bien déroulé et nous avons pu établir quelques contacts. C’est assez suprenant de voir que les gens s’intéressent autant à la technologie.

Après tout ça on est allé faire un petit tour dans les jardins du parcs avant que les gardes nous demandent de rentrer dans nos hotels. Pour le coup, on ne comprend vraiment pas pourquoi.

On postera d’autre trucs plus tard sur le workshop et les challenges du wargames mais pour l’instant il est l’heure d’aller se coucher.

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?

Open the door

Il n’y a pas si longtemps, je repensais à une scène de 60 secondes chrono. Celle où ils sont devant un garage à attendre que le propriétaire ouvre pour cracker le signal et récupérer le code de l’entrée.

En y repensant de plus près, je me suis souvenu que ma copine avait un badge du genre qui lui permet d’ouvrir une porte de garage en centre ville et on m’a prêté un oscilloscope.

Ni une ni deux je saute sur l’occasion pour vérifier la légende. Let’s open the door -> http://www.youtube.com/watch?v=eIrRPLzDrHU#t=2m03s

Ok c’était naze..

Conception de l’antenne

L’antenne se compose simplement d’un fil que l’on va enrouler. Avant d’entrer dans le vif du sujet, on peut faire un petit point sur la conception de la bobine et se souvenir comment un message électromagnétique peut être transformé en électricité. Wikipédia nous dit que

« Le champ électrique d’une onde électromagnétique induit une tension dans chaque petit segment de tout conducteur électrique.Le champ électrique d’une onde électromagnétique induit une tension dans chaque petit segment de tout conducteur électrique. La tension induite dépend de la valeur du champ électrique et de la longueur du segment. Mais la tension dépend aussi de l’orientation du segment par rapport au champ électrique. »

Ceci nous indique qu’il suffit de faire une antenne en réalisant un cercle avec du fil et de brancher notre fil à l’oscilloscope afin de voir le signal transmis par notre émetteur qui ouvre la porte de garage.

En effet le signal obtenu est très parlant (voir capture ci dessous). On voit apparaître un signal en tout ou rien, modulé en amplitude à 100%, avec une porteuse à 31Mhz environ. Lorsqu’on ouvre le boitier de notre émetteur radio qui ouvre la porte de garage, on retrouve un quartz oscillant à 30.975 Mhz. Tout semble donc en accord avec notre mesure.

Enregistrer le signal

La chose étonnante est que le signal est toujours le même. Il est donc tout à fait envisageable de l’enregistrer bêtement avec une carte d’acquisition et de rejouer le signal. Un simple montage ADC – mémoire – DAC permet de rejouer ce signal radio. Cependant, une carte d’acquisition coûte assez cher et on préférerait utiliser un montage moins lourd. Pour se faire, direction démodulation du signal. Le montage classique est un démodulation avec une diode au germanium. L’objectif étant de faire un détecteur de crêtes, les explications et le montage de ce type de circuit se trouve un peu partout sur le net. Dans le cas précis dans lequel nous nous trouvons (trop pauvre pour une diode au germanium), nous utiliserons une diode infrarouge avec un phototransistor.

Si on reprend la courbe capturée à l’oscilloscope, on voit deux phases: une première avec un niveau électrique à zéro, et une seconde avec un niveau électrique oscillant. Lorsque le niveau sera oscillant, la LED s’allumera de manière quasi continue. De l’autre côté un photo-transistor détectera l’allumage de la LED et il ne nous restera plus qu’à lisser ce signal afin d’obtenir un signal logique démodulé.

Montage

La diode émettrice est branchée directement sur notre antenne artisanale. Cette diode a été récupérée sur une vieille télécommande.

Le photo-transistor est simplement relié à la pile, en série, avec une résistance. Un petit condensateur a été ajouté afin de filtrer le bruit environnant. Ce dernier est maintenu au dessus de notre diode avec un scotch. Pour un meilleur rapport signal sur bruit, il eût été préférable d’écarter le plus possible le circuit émetteur du récepteur. Cependant lors de la découpe de la diode de la télécommande, une petite boulette nous a empêché de profiter pleinement des contacts de celle ci. Enfin ça marche.

Le signal obtenu au borne de la résistance vu à l’oscilloscope :

On observe un signal assez bruité mais ça reste lisible. Nous n’avons malheureusement pas le temps de nous plonger d’avantage dans l’étude et la fabrication d’espion plus puissant, mais on peut cependant noter qu’il ne semble pas y avoir de sécurité de type cryptographique sur la clé radio que nous avons testé.
Il est tout a fait possible d’écouter le signal avec du matériel adapté et relativement simple de le démoduler. Le reproduire consiste alors à refaire le même circuit que celui de la clé ce qui est à la portée de n’importe quel bidouilleur en électronique. Celui peut alors être rejoué simplement puisque dans les observation que nous avons faites, le même signal a toujours été émis ce qui permet le rejeu.

Pour éviter ce genre de chose, il aurait fallut envisager un protocole plus sur avec au moins un échange et permettant d’éviter le rejeu. Une question à laquelle nous espérons pouvoir répondre dès que nous aurons un peu de temps.

It’s oversimple isn’t it?