Atelier – Collecte 2 : Envoyer / Recevoir des données depuis le backend Sigfox

Un peu de code pour envoyer vers le Cloud

En reprenant le code source du précédent article, nous pouvons obtenir des float pour nos variables environnementales. Nous allons maintenant limiter leur précision, pour respecter les contraintes de taille de message.

Pour cela, nous allons utiliser une structure de type union : nous allons stocker 2 variables de type différents (float et tableau de byte) sur la même adresse mémoire. On peut ainsi facilement coder la température sur une taille de 4 octets et la luminosité sur 2 octets. Pour l’humidité, étant donné qu’il s’agit d’un pourcentage, on peut se limiter à un octet.

Nous sommes même finalement assez tranquille, puisque nous n’utilisons que 7 octets. Il reste de la place pour ajouter des capteurs !

[cpp]// Sigfox
uint8_t dataSigfox[12];
uint8_t size;
union
{
uint8_t value1[4];
float value2;
}t_union;
union
{
uint8_t value1[2];
uint16_t value2;
}l_union;
uint8_t status;
 
float h = dht.TemperatureHumidityRead(dhtPin, ‘H’);
float t = dht.TemperatureHumidityRead(dhtPin, ‘T’);
float l = readLuminance(lumPin);

printf("*** Measures ***\n");
printf("Luminance : %f\n", l);
printf("Humidity : %f\n", h);
printf("Temperature : %f\n", t);
printf("Send to Sigfox\n");

// fill data array
t_union.value2 = t;
dataSigfox[0] = t_union.value1[3];
dataSigfox[1] = t_union.value1[2];
dataSigfox[2] = t_union.value1[1];
dataSigfox[3] = t_union.value1[0];
 
dataSigfox[4] = (uint8_t) h;

l_union.value2 = (uint16_t) l;
dataSigfox[5] = l_union.value1[1];
dataSigfox[6] = l_union.value1[0];
size = 7;

// Final Frame to send in "data"
printf("Final Frame to send: 0x%X\n", dataSigfox);
 
// Sending packet to Sigfox
status = Sigfox.send(dataSigfox,size);
[/cpp]

Nous pouvons envoyer ces octets à Sigfox en utilisant la méthode Sigfox.send.

Comme pour les articles précédents de cette série, vous trouverez les scripts complets sur notre dépot GitHub.

Pour lancer un envoi simple vers Sigfox, il vous suffit de deux lignes :

[bash]pi@raspberrypi:~/sigfox $ make TARGET=06-send-sigfox-uplink
pi@raspberrypi:~/sigfox $ sudo ./06-send-sigfox-uplink
*** Switch Sigfox ON ***
*** Waiting for user action (push button) ***
*** Measures ***
Luminance : 20 lux
Humidify : 75 %
Temperature : 22°C
*** Sending data to Sigfox ***
*** Sigfox packet sent ***
*** Waiting for user action (push button) ***[/bash]

Le traitement de l’information côté Sigfox

Nous n’allons pas tout de suite nous lancer dans un backend compliqué. Mais nous aimerions quand même décoder les octets envoyés à Sigfox pour les faire apparaitre « en clair » et être capables de retourner une réponse. Il est donc l’heure de dégainer Mockbin, l’outil parfait pour simuler un backend REST. En effet, le but de cette série d’article est de créer une véritable application autour de nos objets connectés. Le backend Sigfox n’est donc qu’une étape, et nous allons au fur et à mesure rerouter les valeurs reçues dans Sigfox vers leur destination finale. Mockbin est un premier pas.

Première étape, créer notre callback dans le backend Sigfox.

Nous sommes sur un callback de type DATA, UPLINK (soit une communication unidirectionnelle).

Nous allons traiter une charge utile de type custom. Ce champ va nous aider à décoder notre tableau d’octets. La documentation est relativement claire et notre charge utile est donc du type temperature::float:32 humidity::uint:8 luminance::uint:16

En laissant cet onglet ouvert, passons maintenant côté Mockbin, pour créer une terminaison à notre callback. Dans un premier temps, un backend tout simple suffira à notre bonheur.

Notre terminaison REST est maintenant prête. Entrons son adresse dans notre callback. Comme nous connaissons les règles et normes du web, nous utiliserons le verbe HTTP POST pour pousser nos données (depuis peu, il est même possible d’utiliser le verbe PUT). Le corps de notre requête sera composé d’un mélange de données issues de Sigfox et de données issues de notre charge utile Custom. Dans le corps de notre JSON, les variables Sigfox sont à mettre entre { }. Il est aussi possible d’utiliser ces variables dans les URLs et donc de les construire selon une véritable grammaire REST.

Le grand moment est arrivé. Il est temps de poster votre premier vrai message à Sigfox. Démarrez votre Pi, lancez le programme ad-hoc, et pressez le bouton. Vous devriez, dans l’ordre, constater dans votre console RPi que le message a bien été envoyé, puis voir apparaitre le message et son indicateur Callback au vert dans Sigfox, et enfin voir vos données en clair dans Mockbin !

Les données descendantes

Utilisons maintenant notre sapin de Noël. Les DEL de notre plaque d’expérimentation vont être pilotées par des données descendantes en provenance de notre backend, à savoir MockBin. Malheureusement, il n’est pas possible d’éditer une une terminaison Mockbin existante. Nous allons donc en recréer une à l’usage de notre application bidirectionnelle. Comme le spécifie la norme, l’appel descendant doit comporter exactement 8 octets pour être valide. Nous le verrons plus tard, mais nous n’avons besoin de que d’un octet pour piloter nos 3 DEL. En respectant la spécification, notre réponse doit être de la forme :

[js]{ "<deviceId>" : "downlinkData" : "<8 octets>" }}[/js]

Malheureusement, Mockbin ne permet pas de générer des réponses dynamique. Il va donc falloir créer une terminaison, ou bin, par objet, qui contiendra son identifiant dans le corps de la réponse. Concernant les données en downlink,  nous allons réserver 2 octets à l’état de nos 3 DEL. Nous verrons plus tard comment interpréter cette réponse, mais dans un premier temps, nous allons renvoyer les 8 octets suivants : 0700000000000000.

Coté Sigfox, nous allons modifier notre callback, pour le rendre BIDIRectionnel, et activer le downlink sur l’écran principal. Notez que vous pouvez maintenant utiliser le flag {ack} dans votre charge utile. Notez aussi que si vous renvoyez une réponse ne respectant pas ce format, ou ayant moins de 8 octets, Sigfox vous gratifiera d’un obscur message, INVALID PAYLOAD, assez frustrant.

Si tout se passe bien, vous devriez voir apparaitre deux magnifiques flèches vertes.

Passons enfin au dernier étage de la fusée, le code sur votre Raspberry Pi. Peu de changement sont à prévoir du coté de l’envoi des données. Nous allons simplement remplacer la méthode d’envoi Sigfox.send par Sigfox.sendACK, qui attend une réponse du portail Sigfox avant de déconnecter le modem. Dans le cadre d’un échange bidirectionnel Sigfox, cette réponse peut être assez longue à venir, de l’ordre de 30 secondes. Prenez donc votre mal en patience.

Si vous utilisez les bibliothèques Cooking Hacks telles quelles, vous aurez la chance de voir que votre modem reçoit une réponse, mais pas de pouvoir en exploiter le contenu.

Pour pouvoir exploiter cette réponse, il nous a fallu modifier le programme C fourni par Cooking Hacks. Vous trouverez l’historique de ce pacth sur leur forum. Notre Github contient bien sûr cette bibliothèque modifiée.

Nous sommes donc en mesure de récupérer les données du downlink, et de les transformer en un integer.

[cpp]int led_state = (int)strtol(reinterpret_cast<const char*>(Sigfox._ackData), NULL, 16);[/cpp]

Dans un souci d’économie, nous allons réduire l’empreinte de l’information et notamment la représentation de nos DEL. Nous réserverons 2 octets, dont chaque bit représentera l’état d’une DEL (0 : éteinte, 1 : allumée). À cet effet , nous utiliserons des masques de bit et les opérateurs de décalage afin de manipuler individuellement ces bits. Le lecteur réveillé notera que 2 octets = 16 bits, ce qui est supérieur aux 3 bits nécessaires à la représentation de l’état de nos 3 DEL, mais à ce stade, nous souhaitons également garder de la place pour les futures évolutions.

Si vous voulez en savoir plus, vous pouvez lire cet article pour débuter dans la représentation binaire des données et les opérateurs qu’elle offre.

[cpp]// LED
#define RED_LED 1
#define GREEN_LED (1 << 1)
#define BLUE_LED (1 << 2)
#define LED_IS_ON(led_id,state) (state & (1 << (led_id-1)))
 
i = 0;
for(;i <= 3; i++) {
if(LED_IS_ON(i, led_state)) {
printf("led %d is on\n", i);
digitalWrite(ledsPin[i], HIGH);
} else {
printf("%d pin is off\n", ledsPin[i]);
digitalWrite(ledsPin[i], LOW);
}
}[/cpp]

Vos DEL devraient, en retour de l’appel Sigfox, s’allumer. Félicitations, vous avez réalisé un aller retour complet. Pour modifier l’état de vos DEL, vous pouvez modifier votre mockbin pour qu’il retourne une autre représentation binaire, en vous basant sur ce tableau :

Pour tester directement le programme :

[cpp]pi@raspberrypi:~/sigfox $ make TARGET=07-send-sigfox-bidir
pi@raspberrypi:~/sigfox $ sudo ./07-send-sigfox-bidir
*** Switch Sigfox ON ***
*** Waiting for user action (push button) ***
*** Measures ***
Luminance : 20 lux
Humidity : 75 %
Temperature : 22°C
*** Sending data to Sigfox ***
*** Sigfox packet sent ***
*** Sigfox downlink packet received ***
Led wired on pin 2 is on
Led wired on pin 3 is on
Led wired on pin 4 is on
*** Waiting for user action (push button) ***[/cpp]