Réseau de capteurs

Contexte

Objectif initial du projet

L'objectif du projet est de réaliser un réseau de capteurs pouvant être implanté chez un particulier. Or comme le Wifi n'est pas captable partout dans la maison, il est nécessaire de réaliser un réseau maillé qui pourrait ainsi relayer les information jusqu'à un module central. L'avantage important d'utiliser des émetteurs pas en Wifi est aussi une économie d'énergie très importante. Ainsi les capteurs pourraient tenir plusieurs mois sur une charge, contrairement à quelques jours/semaines avec du wifi. Il est également nécessaire de mettre en place un moyen de voir et collecter les données transmises par les capteurs.

Matériel et logiciel

Choix n°1

• Des Openmotes (embarquant un microcontrôleur CC2538)
• Riot OS
• Une Raspberry Pi 2 embarquant un serveur web

Choix n°2

• Les montres EZ430 Chronos dde Texas Instrument (embarquant un microcontrôleur CC1111)
• RiotOS (à priori compatible avec cet équipement)
• Une Raspberry Pi 2 embarquant un serveur web

Choix final

• Un ESP8266 avec un capteur de température/humidité
• L'IDE Arduino avec une bibliothèque spécifique aux ESP
• Une Raspberry Pi 2 embarquant un serveur web

Avancement du projet

Le matériel et les logiciels devant être utilisés pour le projet étant expérimentaux, l'avancement s'est fait en tâtonnant. Nous décrivons donc ici les méthodes employées et les différents microcontrôleurs que nous avons tenter de faire fonctionner avant de nous rabattre sur les ESP.

OpenMote et RiOT OS

http://www.riot-os.org/

http://www.openmote.com/software/riot.html

https://github.com/RIOT-OS/RIOT/wiki/Board:-OpenMote

https://github.com/RIOT-OS/RIOT/tree/master/boards/openmote

https://github.com/RIOT-OS/RIOT/wiki/Introduction

http://www.riot-os.org/files/riotlab-tutorial.pdf

Dans un premier temps, nous cherchons à faire un "Hello World" sur les OpenMote. Il faut installer un OS léger sur ces puces. Il existe plusieurs systèmes comme FreeRTOS (pour le temps réel), Contiki ou encore RiOT. Ces deux derniers sont intéressants pour notre application où nous cherchons à mettre en place un réseau maillé entre nos noeuds de capteurs (protocole RPL). Nous décidons de partir sur RiOT car il est plus récent et plus léger (en théorie).

Compilation d'un programme example de RiOT

apt-get install gcc-arm-none-eabi
export PATH=${PATH}:/usr/bin/arm-none-eabi-gcc
git clone https://github.com/RIOT-OS/RIOT.git

Pour compiler, on pourra utiliser un example dans les fichiers (dans RIOT/examples). Pour compiler, on lance la commande :

make all

Les fichiers sont dans le nouveau dossier bin créé par la commande. Il peut éventuellement s'avérer nécessaire d'installer la version 32bits de libc6-dev (package libc6-dev-i386).

Flash du programme sur l'OpenMote

Avec RiOT, la méthode préconisée pour flasher la carte est d'utiliser une interface JTAG. Nous allons se passer de cette interface (nécessitant un adaptateur payant) pour flasher la carte via l'UART. On récupère le script :

git clone --recursive https://github.com/OpenMote/openmmote-bsl.git

Nous avons dû modifier le code source du fichier openmote-bsl.py, en remplaçant la ligne :

#openmote_bsl_path = "../../tools/openmote-bsl"
openmote_bsl_path = "."

Nous pouvons maintenant flasher l'OpenMote avec la commande :

python openmote-bsl.py /path/to/file.bin --board openbase

/!\ Attention il faut éxecuter cette commande en étant dans le dossier d'openmote-bsl. S'il y a un problème, il est possible qu'il vous manque un package :

python-serial

Cependant, malgré plusieurs tentatives, nous n'avons pas pu obtenir de résultats. En effet il semblerait que RiOT OS ne soit pas réellement porté sur ce matériel (du moins sur le repo officiel). Etant donné le peu de temps disponible, nous avons abandonné cette plateforme.

EZ430 et Riot OS

N'ayant pas réussi à faire fonctionner l'Openmote, on a alors essayé de flasher Riot OS sur le microcontrôleur embarqué dans la montre EZ430 Chronos de Texas Instrument. Cette montre connectée communique avec un récepteur pouvant se brancher en USB à un ordinateur à une fréquence de 915MHz. Pour flasher l'OS sur la montre, il a été nécessaire de la démonter, retirer la pile et de la connecter avec un FTDI à une carte USB.

Pour compiler le système d'exploitation, nous avons réutilisé les sources de Riot OS que nous avions cloné depuis GitHub en changeant la cible du Makefile de manière à cibler le CC430.

Pour flasher, la méthode est plus simple. Il suffit de faire un make all suivi d'un make flash (comme préconisé sur le GitHub de RiOT OS).

ESP8266

Après ces tentatives infructueuses pour faire fonctionner le matériel, nous avons récupéré un module WiFi/Arduino ESP8266, accompagné d'un capteur de température. Nous nous retrouvons à développer un projet du même acabit que le projet Station météo connectée.

Nous avons réussi à récupérer les mesures et les écrire dans un fichier sur un serveur distant. L'idée est de compiler ces données avec les dates dans un fichier JSON pour pouvoir faire l'affichage simplement avec un site Internet, basé sur Bootstrap.

Nous avons utilisé l'IDE Arduino pour flasher la puce (instructions ici).