Créer une application avec Lora32u4 pour The Things Network

Programmez les cartes Lora32u4 pour créer une application IoT enregistrée sur The Things Network

Difficulté

Medium Moyen

Durée

1 hour(s) heure(s)

Catégories

Électronique

Coût

14 EUR (€)

The Things Network, LoRa, LoRaWAN, IoT, Communauté, Open Source, LoRa32u4, Labsud Créer_une_application_avec_Lora32u4_pour_The_Things_Network_lora32u4.JPG fr none Technique 0

Introduction

The Things Network est une initiative communautaire dans le domaine de l'internet des objets (ou IoT) permettant de raccorder des passerelles ou d'utiliser des passerelles mises en place par ses membres pour transmettre par radio des informations issues de capteurs.

La spécificité de la liaison radio est d'utiliser la modulation LoRa, des transmissions longues distances (plusieurs kilomètres) avec une faible consommation d'énergie, et qui peut donc fonctionner longtemps sur batteries dans des zones non couvertes par wifi ou bluetooth.

Les messages envoyées par radio sont au format LoRaWan, qui assure l'intégrité du message ainsi que son cryptage.

La carte LoRa32u4 réuni sur un seul support :

• un émetteur-récepteur LoRa,
• un microcontroleur Atmel 32u4 ,
• un connecteur pour batterie LiPo 3,7V
• un connecteur USB
• un circuit de gestion de charge de la pile par l'alimentation USB
• des broches d'entrée-sortie permettant de raccorder toute sorte de capteur
• la compatibilité avec l'environnement de programmation Arduino

Bref, c'est un moyen très économique de créer son propre capteur I oT à raccorder sur The Thing Network

La procédure décrite est pour une programmation sous windows

Pour que les opérations décrites ci-dessous donnent un résultat, il faut bien entendu que vous soyez à portée d'une passerelle The Thing Network

1. 
2. 

Matériaux

- une carte LoRa32u4 II (choisir la fréquence de 868MHz)

Optionnel :

- une batterie LiPo 3,7V avec connecteur JST PH 2mm

- une antenne 868 MHz avec connecteur u.fl (sinon un morceau de fil électrique de 8cm suffit)

Outils

- un câble USB vers micro USB

- un fer à souder suivant les versions de la carte

Étape 1 - Installer les pilotes et bibliothèques

1 - Télécharger les fichiers Driver windows et Arduino Hardware folder sur la page BSFrance

2 - Pour les drivers, il suffit de dézipper et de cliquer sur adafruit_drivers.exe. Parmi la liste des drivers proposés, il faut choisir Feather32u4

3 - Bon, là, normalement, il est possible de brancher la carte sur le port USB de l'ordinateur.

Il est possible que vous ayez le message que l'installation du pilote n'a pas été possible. Pas de panique, on y reviendra

3 - Pour les fichiers Arduino, il faut le dézipper dans le répertoire Mes Documents/Arduino/hardware (ce qui est le répertoire par défaut de l'installation de l'environnement Arduino, mais peut-être différent suivant votre installation. si le sous-répertoire hardware n'existe pas, créez le. Cette bibliothèque sert à gérer le microcontrôleur AT Mega32u4 de la carte.

4 - Démarrez l'IDE Arduino. Vous devriez pouvoir trouver la carte dans le menu Outils > Type de carte > LoRa32u4II 868

5 - Dans l'environnement Arduino, à ce stade on sélectionne le port par le menu Outils > Port, mais s'il y a eu l'erreur d'installation de pilote précédemment mentionnée, le port n'apparait pas. Il faut appuyer sur le bouton reset de la carte et sélectionner à nouveau, dans le laps de temps du reset, le menu Outils > Port. Là normalement le port devrait apparaitre quelques instants et on peut le sélectionner.

6 - Il reste encore à installer un bibliothèque : la bibliothèque LMIC qui contient les fichiers pour le protocole LoraWan. Pour cela il y a 2 méthodes :

Méthode 1 :

• La première est d'aller dans le menu Croquis > Inclure une bibliothèque > Gérer les bibliothèques.
• Dans la barre de recherche, du gestionnaire de bibliothèque, tapez "lmic"

Si vous ne voyez rien apparaitre, vérifiez que les listes déroulantes Type et Sujet soient bien sur "Tout"

• Choisissez d'installer le bibliothèque IBM LMIC Framework

Méthode 2 :

• Téléchargez l'archive du projet GitHub https://github.com/matthijskooijman/arduino-lmic dans le répertoire Mes Documents/Arduino/Libraries. Vous devriez avoir un répertoire arduino-lmic-master

7 - Lorsque cette bibliothèque est bien installée, vous pouvez choisir dans le menu Fichier > Exemples > LMIC-Arduino le sketch ttn-otaa

Pour faire court, la différence entre les sketches ttn-abp et ttn-otaa vient des deux différentes façon de s'enregistrer sur le réseau The Thing Network (par enregistrement, je parle de l'échange qui a lieu entre notre carte et la passerelle TTN lors de la mise sous tension de la carte)

La première est l'Activation By Personalization (ou abp) pour laquelle il faut avoir une adresse réseau de la carte appelée DevAddr)

La seconde est l'Over-The-Air-Activation (ou otaa). Dans ce mode DevAddr est transmis automatiquement pendant la phase d'enregistrement.

Étape 2 - Préparation de la carte

Lorsque vous avez téléchargé les drivers et les bibliothèques Arduino sur la page de BSFrance, vous avez du voir qu'il y avait un schéma de la carte (Pinout diagram )

Sur ce schéma, vous pouvez voir que qu'il y a une entrée appelée DIO1 en bas à gauche. Or il y a des fortes chances que la carte que vous ayez en main soit une révision 1.2 (c'est marqué derrière) et sur cette révision, DIO1 n'est pas là, mais à l'arrière de la carte (on voit le numéro de version sur la photo, ainsi que les pins IO1, IO2 et IO3 en face des pins 1, 2 et 3 respectivement.

Les broches DIO0 à DIO3 sont des broches de la puce LoRa, elles servent au pilotage de la puce par le microcontroleur.

Le sketch utilise DIO0 et DIO1 qui est en réalité un port de la puce LoRa de la carte en le reliant à une entrée du microcontrôleur.

Le tableau en bas à droite du schéma nous éclaire un peu sur ces liaisons. On voit que DIO° est câblé en interne sur la carte sur la broche 7.

Ce n'est pas la cas de la broche DIO1 qui doit être câblé par nos soins. Sans cette liaison, le sketch se bloque en attendant le signal.

Dans le cas d'une carte rév. 1.2, le plus simple est de faire un pont de soudure entre IO1 et la broche 1 qui sont face à face (comme on le voit sur la photo). Pour du LoRa (ce qui est notre cas) on ne se préoccupe pas de IO2 ni IO3.

Si la carte est vraiment comme sur le schéma, on relie DIO1 à la broche 2 avec un fil électrique.

Étape 3 - Petit tour rapide d'une application The Things Network

Pour utiliser TTN, il faut avoir un compte sur https://www.thethingsnetwork.org/.

C'est facile, c'est gratuit, je ne m'y attarde pas.

Lorsqu'on est loggé avec son compte, il faut aller dans Console et choisir Applications.

Cliquer sur add application

Sur la page, renseigner le champ Application ID en donnant un nom significatif en minuscules sans espaces, mais on peut utiliser - et _

Vérifier que Handler registration soit bien sur ttn-handler-eu

Et voilà, cliquez sur le bouton vert Add application

La page qui s'affiche résume la création d'application, rappelle son nom et donne l'Application EUIs généré par TTN.

Ce que l'on vient de créer, c'est l'application du coté du serveur. Il faut encore déclarer que cette application est en réalité alimentée en données par une carte (un "device") qui transmet les données de ses capteurs ou autres.

Sur cette meême page, on voit qu'il y a justement une partie Device, avec un lien register device.

Cliquez dessus et vous arrivez sur une nouvelle page

Renseignez Device ID en donnant un nom un nom significatif en minuscules sans espaces, mais on peut utiliser - et _

Normalement, Device EUI et App Key sont déterminés par TTN. Si pour un des deux champs vous avez l'impression qu'il faut rentrer quelque chose, cliquez à gauche du champ sur les deux flèches croisées et le champ devient "this field will be generated", ce qui est exactement ce qu'on veut.

En bas de la page, App EUI est rappelé, pas besoin d'y faire attention

On clique sur Register et on arrive sur la page qu'il nous faut.

Sur cette page, on a dans l'ordre

Device EUI

Application EUI

App Key

qui sont les 3 informations dont on aura besoin pour renseigner les champs correspondants dans le sketch.

On peut revenir sur cette page quand on veut ultérieurement.

Souvenez vous siimplement que la page est la page DEVICE OVERVIEW si jamais vous vous perdez dans les pages sur le site TTN et qu'on y va en cliquant sur Applications > le nom de l'application > DEVICES > le nom du device

Voilà, coté TTN, tout est près et il ne reste plus qu'a envoyer des données.

Étape 4 - Paramétrage du sketch

/*******************************************************************************

   Copyright (c) 2015 Thomas Telkamp and Matthijs Kooijman

   Permission is hereby granted, free of charge, to anyone

   obtaining a copy of this document and accompanying files,

   to do whatever they want with them without any restriction,

   including, but not limited to, copying, modification and redistribution.

   NO WARRANTY OF ANY KIND IS PROVIDED.

   This example will send Temperature and Humidity

   using frequency and encryption settings matching those of

   the The Things Network. Application will 'sleep' 7x8 seconds (56 seconds)

   This uses OTAA (Over-the-air activation), where where a DevEUI and

   application key is configured, which are used in an over-the-air

   activation procedure where a DevAddr and session keys are

   assigned/generated for use with all further communication.

   Note: LoRaWAN per sub-band duty-cycle limitation is enforced (1% in

   g1, 0.1% in g2), but not the TTN fair usage policy (which is probably

   violated by this sketch when left running for longer)!

   To use this sketch, first register your application and device with

   the things network, to set or generate an AppEUI, DevEUI and AppKey.

   Multiple devices can use the same AppEUI, but each device has its own

   DevEUI and AppKey.

   Do not forget to define the radio type correctly in config.h.

 *******************************************************************************/

#include <avr/sleep.h>

#include <avr/wdt.h>

#include <lmic.h>

#include <hal/hal.h>

#include <SPI.h>

#include "LowPower.h"

#include <Arduino.h>

int sleepcycles = 7;  // every sleepcycle will last 8 secs, total sleeptime will be sleepcycles * 8 sec

bool joined = false;

bool sleeping = false;

#define LedPin 2     // pin 13 LED is not used, because it is connected to the SPI port

// This EUI must be in little-endian format, so least-significant-byte

// first. When copying an EUI from ttnctl output, this means to reverse

// the bytes. For TTN issued EUIs the last bytes should be 0xD5, 0xB3,

// 0x70.

static const u1_t DEVEUI[8]  = {  }; //lsb

static const u1_t APPEUI[8] = {  }; //lsb

// This key should be in big endian format (or, since it is not really a

// number but a block of memory, endianness does not really apply). In

// practice, a key taken from ttnctl can be copied as-is.

// The key shown here is the semtech default key.

static const u1_t APPKEY[16] = {  }; //msb

static void initfunc (osjob_t*);

// provide APPEUI (8 bytes, LSBF)

void os_getArtEui (u1_t* buf) {

  memcpy(buf, APPEUI, 8);

}

// provide DEVEUI (8 bytes, LSBF)

void os_getDevEui (u1_t* buf) {

  memcpy(buf, DEVEUI, 8);

}

// provide APPKEY key (16 bytes)

void os_getDevKey (u1_t* buf) {

  memcpy(buf, APPKEY, 16);

}

static osjob_t sendjob;

static osjob_t initjob;

// Pin mapping is hardware specific.

// Pin mapping

const lmic_pinmap lmic_pins = {

  .nss = 8,

  .rxtx = LMIC_UNUSED_PIN,

  .rst = 4, // Needed on RFM92/RFM95? (probably not) D0/GPIO16

  .dio = {7, 1, LMIC_UNUSED_PIN}, // Specify pin numbers for DIO0, 1, 2

  // connected to D7, D6, -

};

void onEvent (ev_t ev) {

  int i, j;

  switch (ev) {

    case EV_SCAN_TIMEOUT:

      Serial.println(F("EV_SCAN_TIMEOUT"));

      break;

    case EV_BEACON_FOUND:

      Serial.println(F("EV_BEACON_FOUND"));

      break;

    case EV_BEACON_MISSED:

      Serial.println(F("EV_BEACON_MISSED"));

      break;

    case EV_BEACON_TRACKED:

      Serial.println(F("EV_BEACON_TRACKED"));

      break;

    case EV_JOINING:

      Serial.println(F("EV_JOINING"));

      break;

    case EV_JOINED:

      Serial.println(F("EV_JOINED"));

      // Disable link check validation (automatically enabled

      // during join, but not supported by TTN at this time).

      LMIC_setLinkCheckMode(0);

      digitalWrite(LedPin, LOW);

      // after Joining a job with the values will be sent.

      joined = true;

      break;

    case EV_RFU1:

      Serial.println(F("EV_RFU1"));

      break;

    case EV_JOIN_FAILED:

      Serial.println(F("EV_JOIN_FAILED"));

      break;

    case EV_REJOIN_FAILED:

      Serial.println(F("EV_REJOIN_FAILED"));

      // Re-init

      os_setCallback(&initjob, initfunc);

      break;

    case EV_TXCOMPLETE:

      sleeping = true;

      if (LMIC.dataLen) {

        // data received in rx slot after tx

        // if any data received, a LED will blink

        // this number of times, with a maximum of 10

        Serial.print(F("Data Received: "));

        Serial.println(LMIC.frame[LMIC.dataBeg], HEX);

        i = (LMIC.frame[LMIC.dataBeg]);

        // i (0..255) can be used as data for any other application

        // like controlling a relay, showing a display message etc.

        if (i > 10) {

          i = 10;   // maximum number of BLINKs

        }

        for (j = 0; j < i; j++)

        {

          digitalWrite(LedPin, HIGH);

          delay(200);

          digitalWrite(LedPin, LOW);

          delay(400);

        }

      }

      Serial.println(F("EV_TXCOMPLETE (includes waiting for RX windows)"));

      delay(50);  // delay to complete Serial Output before Sleeping

      // Schedule next transmission

      // next transmission will take place after next wake-up cycle in main loop

      break;

    case EV_LOST_TSYNC:

      Serial.println(F("EV_LOST_TSYNC"));

      break;

    case EV_RESET:

      Serial.println(F("EV_RESET"));

      break;

    case EV_RXCOMPLETE:

      // data received in ping slot

      Serial.println(F("EV_RXCOMPLETE"));

      break;

    case EV_LINK_DEAD:

      Serial.println(F("EV_LINK_DEAD"));

      break;

    case EV_LINK_ALIVE:

      Serial.println(F("EV_LINK_ALIVE"));

      break;

    default:

      Serial.println(F("Unknown event"));

      break;

  }

}

void do_send(osjob_t* j) {

  byte buffer[2] = {1, 2};

  // It is a bad idea to send ASCII for real, only use this when developing!!

  //buffer[0]='H';

  //buffer[1]='i';

  if (LMIC.opmode & OP_TXRXPEND) {

    Serial.println(F("OP_TXRXPEND, not sending"));

  } else {

    // Prepare upstream data transmission at the next possible time.

    LMIC_setTxData2(1, (uint8_t*) buffer, 2 , 0);

    Serial.println(F("Sending: "));

  }

}

// initial job

static void initfunc (osjob_t* j) {

  // reset MAC state

  LMIC_reset();

  LMIC_setClockError(MAX_CLOCK_ERROR * 1 / 100);

  // start joining

  LMIC_startJoining();

  // init done - onEvent() callback will be invoked...

}

void setup()

{

  delay(1000);

  Serial.begin(9600);

  Serial.println(F("Starting"));

  delay(1000);

  os_init();

  // Reset the MAC state. Session and pending data transfers will be discarded.

  os_setCallback(&initjob, initfunc);

  LMIC_reset();

}

void loop(){

  // start OTAA JOIN

  if (joined == false) {

    os_runloop_once();

  }

  else {

    do_send(&sendjob);    // Sent sensor values

    while (sleeping == false){

      os_runloop_once();

    }

    sleeping = false;

    for (int i = 0; i < sleepcycles; i++) {

      LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);    //sleep 8 seconds

    }

 }

  digitalWrite(LedPin, ((millis() / 100) % 2) && (joined == false)); // only blinking when joining and not sleeping

}

Étape 5 - Téléversement du sketch

Normalement, il ne devrait pas y avoir d'étape spécifique pour le téléversement puisque c'est une opération qui se passe sans encombre.

Dans notre cas, il y a une petite condition supplémentaire qui provient de la spécificité de la puce ATMega32u4.

Cette puce dispose de sa propre liaison USB intégré (donc pas de FTDI sur la carte pour assurer la liaison USB<>UART comme pour les cartes arduino).

Cette particularité rend la liaison USB assez délicate car si le microcontrôleur est planté, s'il est un mode deep sleep, et dans d'autres cas encore, il n'y a plus de liaison USB (c'est pourquoi le port n'apparait pas toujours et qu'il faut faire un reset de la carte qui active pendant quelques secondes la liaison USB en attendant le chargement éventuel d'un sketch.

Donc lorsque vous activez le téléversement depuis l'environnement Arduino, il faut aussi appuyer sur reset pour forcer la carte à activer sa liaison USB.

Mais si la compilation dure un peu trop longtemps, la phase post-reset sera peut-être déja terminée.

Pour pallier ce problème, le mieux est d'aller dans fichier > préférence de l'environnement Arduino et de cocher Afficher les résultats détaillés pendant le téléversement.

De cette façon, vous voyez apparaitre dans la console du bas de l'environnement Arduino le moment où avrdude (la partie du logiciel qui s'occupe de la communication avec la carte) cherche le port COM correspondant. la console affiche en boucle des lignes similaires à celles de la photo ci-contre. Par défaut, avrdude ne voit que le port COM1 qui n'est pas le bon et il essaie plusieurs fois. Si vous appuyez à ce moment là sur reset, avrdude trouvera la carte et commencera le transfert.