Il est temps de vous parler un peu de la partie logiciel du projet OpenAlarm qui est en 2 parties : le logiciel interne (firmware) aux OpenAlarm Node et la partie qui tourne sur l'ordinateur, dans cette première partie, je vais vous présenter uniquement le fonctionnement des OpenAlarm Node.

Cet article est volontairement technique et rentre dans des détails que l'utilisateur final n'aura pas à connaître mais si vous souhaitez participer au projet, vous aurez besoin de ces informations.

Principe de fonctionnement

Le fonctionnement des OpenAlarm Node est plutôt simple, le système est conçu pour être utilisable sans base, c'est à faire qu'avec juste 2 Node (et un ordinateur), vous avez un système pleinement utilisable, en effet, chaque Node embarque le code nécessaire pour la surveillance de grandeur issue de capteur (mouvement, température, luminosité, courrier dans la boite aux lettres, etc...) mais également celui pour servir de base réceptionnant les messages des autres capteurs.

Un Node à donc plusieurs modes de fonctionnement :

À la mise sous tension, un Node démarrera automatiquement en mode surveillance si ce dernier n'est pas branché à un ordinateur et ne reçoit pas de commande le lançant dans un autre mode.

Difficile de faire plus simple, non ?

Les sources

Tous les fichiers sources sont disponibles dans le dossier /src dont voici l'arborescence :

Le firmware

Les sources et librairies

Le firmware de chaque node est écrit en C et compilé avec les outils Arduino, j'ai utilisé Ino (une interface en ligne de commande pour Arduino) pour compiler / programmer les OpenAlarm Node mais vous pouvez bien entendu utiliser l'environnement par défaut d'Arduino.

Les librairies utilisées :

Afin de compiler les sources avec Ino, voici les étapes à suivre :

  1. Installer Ino, ça peut être utile ;)
  2. Placez-vous dans le dossier src/node
  3. Lancez la commande ino build et voilà, vous pouvez maintenant envoyer le firmware sur le node (après avoir appuyé sur le bouton reset de ce dernier) via la commande ino upload

Voilà, vous avez un OpenAlarm Node fonctionnel...

Les commandes

Lorsque vous branchez un OpenAlarm Node sur le port USB de votre ordinateur, un périphérique série est créé et vous permet de dialoguer directement avec ce dernier via des commandes.

Pour lire la configuration du Node connecté :

$ ino serial
config
OpenAlarm node, version oa10
- nodeid      : 1
- freq        : 433Mhz
- group       : 210
- ack         : yes
- power       : 0 (highest)
- autostart   : yes
- cmd timeout : 15 second(s)
- usb timeout : 15 second(s)
- remote      : yes (wait error cycle: 7)
- key         : AKdlIqdjMKAQwJKz
Profile 0:
- period    : 3 second(s)
- feedback  : yes
- eint wait : 3

En rouge, nous avons la commande saisie sur l'ordinateur pour démarrer la liaison serie via USB et en vert la commande saisie via la liaison série sur le Node, le reste étant la réponse faite par la Node.

Liste des commandes disponibles :

Liées à la configuration :

Commandes permettant de faire rentrer la node dans des modes spécifiques :

Liées à la partie radio :

Liées aux tests :

Toutes les commandes ne sont pas toujours directement accessibles à des fins d'économies de mémoire et sont activables ou non via des #define.

Les paquets

J'ai voulu faire un système totalement configurable, ainsi, le format des paquets envoyés par la liaison radio n'est pas fixe et modifiable à souhait.

Utilisons la commande frame afin d'afficher le format courant :

frame
Frame (type: 2, size: 9) :
-> [type] [counter] [waketype] [wakearg] [input0,input1,input2] [voltage] [temperature]

La commande frame affiche alors le contenu d'une frame telle qu'elle sera envoyée à la base, voici une explication sur les différents éléments :

En rouge, il s'agit de l'entête fixe (le préambule), en vert, nous avons ce qui reste totalement configurable par l'utilisateur

Si dans votre application, vous n'avez besoin que de la température, il vous suffit de le spécifier à l'aide de la commande frame :

frame set 4 65
Frame set !

Explication des arguments envoyés :

Si nous retapons la commande frame, nous voyons que le format à bien changé :

frame
Frame (type: 4, size: 5) :
-> [type] [counter] [waketype] [wakearg] [temperature]

Au sujet du contenu des frames, dans la précédente commande, nous voulions une frame constituée uniquement de la température et nous avons utilisé 65 pour le spécifier, voici une liste de ce qu'il est possible d'utiliser pour constituer une frame :

Les interruptions

Nous venons de le voir, au travers des frames, nous pouvons envoyer les informations que nous voulons à la base, ces informations seront envoyées à intervalle régulier défini au préalable (par exemple, avec un intervalle d'une minute), le reste du temps, l'OpenAlarm Node reste en veille afin de consommer le moins possible.

Mais comment faire si un événement se produit exactement durant cette veille ? C'est là qu'intervienne les interruptions qui vont sortir de veille notre Node afin d'envoyer immédiatement une frame dans le but d'alerter la base.

Le microcontrôleur possède des interruptions matérielles sur certaines de ses entrées / sorties et afin de spécifier lesquelles vont nous servir pour sortir le Node du sommeil, nous utilisons la commande int comme ceci :

La commande int sans argument nous liste les interruptions actuelles :

int
Not int !

Ajoutons 2 interruptions, la 2 correspondant à l'entrée / sortie 0 afin de surveiller un front descendant (falling) et la 0 pour un front montant (rising) :

int add 2 falling
Int added !
int add 0 rising
Int added !

Listons de nouveau les interruptions :

int
Ints (size: 2) :
- 2 (input 0) falling
- 0 (input 3) rising

Voilà, lorsque l'OpenAlarm Node rentrera en mode guard, il configurera les interruptions ci-dessus afin qu'il sorte du mode veille en cas d’événement pour envoyer une frame d'alerte.

Les entrées / sorties

Voilà une dernière commande qui va nous être bien utile, elle permet de configurer les entrées / sorties dans un état prédéfinie au moment de l'entrée en veille.

io
Inputs :
- io0 : input pullup
- io1 : input nopullup
- io2 : input nopullup
- io3 : input nopullup
- io4 : input nopullup
- io5 : input nopullup
- io6 : input nopullup
- io7 : input nopullup
- io8 : input nopullup
- io9 : input nopullup

Les profiles

Nous venons de voir les paquets, les interruptions et les entrées / sorties, OpenAlarm permet de créer des profiles qui regroupent tous ces paramètres afin de changer rapidement de configuration sans avoir à renvoyer tous les réglagles.

On peut ainsi imaginer être sur un profile simple lorsque vous êtes chez vous ou l'OpenAlarm Node envoie à une période de 5 minutes les paquets contenant le contenu des mesures de ces capteurs, et, lorsque vous partez de chez vous, vous basculez à distance sur un autre profile ou la période d'envoi est de 15 secondes.
En procédant ainsi, on gagne en autonomie.

Un profile peut contenir les informations suivantes :

Chaque OpenAlarm Node peut avoir un maximum de 3 profiles différents.

Pour basculer d'un profile à un autre, il suffit d'utiliser la commande set ainsi :

set profile set 1
Done

Un exemple concret

Voici un exemple concret d'utilisation de ce que nous venons de voir.

Imaginez que vous vouliez surveiller une pièce isolée avec un détecteur de mouvement, vous souhaitez également détecter des chocs (dans le cas ou votre Node est placé sur une des portes par exemple) et tant qu'à faire, vous aimeriez connaître la température de cette pièce.

Nous avons 3 capteurs utilisées :

Nous nous connectons alors sur l'OpenAlarm Node :

$ ino serial
frame set 2 8 9 64
Frame set !
io set 0 input nopullup
Io set !
io set 1 input pullup
Io set !
int add 2 falling
int set !
int add 3 rising
int set !

Explications pour chaque commande :

Pour voir le paquet qui sera envoyé, utilisez la commande frame :

frame
Frame (type: 2, size: 7) :
-> [type] [counter] [waketype] [wakearg] [input0,input1] [temperature]

Une fois ceci réalisé, on peut configurer la période à laquelle le Node va nous donner des nouvelles de lui (1 minute et 30 secondes ici) puis on le lance en mode surveillance :

set period 90
Done
guard
Starting guard mode !

Maintenant, l'OpenAlarm Node nous enverra toutes les 1 minute et 30 secondes la frame que nous avons configuré et si un évènement survient via le capteur de mouvement ou le capteur de vibration, une frame est immédiatement envoyée.

Notre Node est pleinement fonctionnel en surveillance de sa zone mais imaginons que nous voulions changer la période d'envoi des frames, comme nous sommes feignants, nous n'allons pas aller chercher le Node mais tout simplement nous connecter à distance dessus afin de changer le paramètre voulu :

remote 1 AKdlIqdjMKAQwJKz 
Connecting...
Success!
period 60
power 3
exit
Disconnected!

Dans cet exemple, l'utilisateur se connecte au Node 1 avec la clef AKdlIqdjMKAQwJKz, puis saisie 3 commandes (en orange) afin de changer la période d'envoi des informations à 60 secondes et modifie la puissance d'émission avant de se déconnecter avec la commande exit.

Voilà pour le tour de présentation du fonctionnement logiciel des OpenAlarm Node, dans un prochain article, je présenterai l'interface Python permettant de réaliser les mêmes opérations mais de façon automatisées...