Arduino IoT Cloud – Teil 2: Arduino SIM und Sigfox

Über den Beitrag

In meinem letzten Beitrag hatte ich eine Einführung in die Arduino IoT Cloud gegeben. In diesem Beitrag möchte ich darauf aufbauen und aufzeigen, wie ihr euch mithilfe der Arduino SIM Karte oder des Sigfox Dienstes vom Vorhandensein eines W-LANs unabhängig machen könnt.

Mit der Arduino SIM Karte könnt ihr über das 3G Netz auf die Arduino IoT Cloud zugreifen. Die Sigfox Lösung nutzt eine auch 0G genannte Technologie. Mit ihr greift ihr nicht auf die Arduino IoT Cloud zu, sondern nutzt ein System des französischen Telekommunikationsunternehmens Sigfox. Ich habe dieses Thema trotzdem unter die Überschrift „Arduino IoT Cloud“ gepackt, da es mithilfe des Arduino Boards MKR FOX 1200 realisierbar ist. 

Vorab muss ich sagen, dass es bei beiden Lösungen Einschränkungen hinsichtlich des Datenvolumens bzw. der möglichen Aktualisierungen pro Zeiteinheit gibt. Regelmäßige Datenaktualisierung im Sekundentakt ist nicht möglich. Ob das stört oder nicht, hängt von der Art des Projektes ab. 

Der Beitrag setzt Wissen aus dem vorherigen Beitrag voraus. Wenn also Fragen auftauchen, könnten sie dort eventuell beantwortet werden.

Arduino SIM

Was ihr braucht

Board und SIM Karte

Das Board für die Arduino SIM - der MKR GSM 1400
Das Board für die Arduino SIM – der MKR GSM 1400

Das derzeit einzige Board, das (derzeit) mit der Arduino SIM funktioniert, ist der MKR GSM 1400. Dieses Board gibt es zum Beispiel hier im Arduino Store für stolze 60 Euro, wobei ihr mit Steuern und Versand bei knapp 80 Euro landet (Stand Mai 2020). Ihr bekommt es aber auch in vielen Elektronik-Online-Shops, allerdings nicht wirklich günstiger. Eine Antenne ist normalerweise dabei, nicht aber die SIM Karte.

Eine Arduino SIM Karte bekommt ihr für 3 Euro (+ Steuern / Versand) hier im Arduino Store. Die Bedingungen sind meines Erachtens sehr fair, was vielleicht ein bisschen über den hohen Preis des Boards hinwegtröstet. Die ersten drei Monate sind frei mit 10 MB Guthaben, ab dann kostet es 1,50 $/Monat für 5 MB/Monat. Ihr könnt die Arduino SIM Karte bis zu sechs Monaten pausieren und den Vertrag jederzeit kündigen. Verlasst euch aber bitte nicht blind auf meine Angaben, sondern überprüft die aktuellen Bedingungen! Mit 5 MB lässt sich einiges realisieren, aber auch nicht alles. Dazu später mehr.

Ihr könnt das Board und die SIM Karte auch im Kit kaufen, schaut hier. Neulich waren Board und Kit ausverkauft. Dann müsst ihr warten oder das Board und SIM Karte getrennt kaufen. 

Weiteres

Dann benötigt ihr noch:

  • einen Arduino Account
  • den Arduino Create Agent
  • den Maker Plan, falls ihr sehr viel probieren oder mehrere Boards in der Arduino IoT Cloud nutzen wollt

Schaut zu diesen Punkten bitte ggf. in meinen letzten Beitrag.

Dann müsst ihr der Arduino IDE noch die SAMD Boards „beibringen“, falls ihr das nicht vorher schon einmal getan habt. Wenn ihr dafür Hilfe braucht, schaut hier in den Getting Started Seiten.

Das Arduino MKR GSM 1400 Board

Das MKR GSM 1400 Board basiert wie alle derzeit verfügbaren Arduino IoT Boards auf dem SAMD21 Cortex-M0+ 32bit Low Power ARM Mikrocontroller. Darüber habe ich schon im letzten Beitrag kurz berichtet. Mehr technische Details zu dem Board findet ihr hier. Zudem kann ein Blick in die schon erwähnten Getting Started Seiten nicht schaden. Vor allem beachtet bitte, dass das Board auf 3.3 Volt läuft.

Arduino MKR GSM 1400 Board in die Arduino IoT Cloud bringen

Nun geht es los. Zu diesem Zeitpunkt müsst ihr das Board und die SIM Karte haben. Zudem muss die SIM Karte freigeschaltet sein, was normalerweise innerhalb von 24 h der Fall ist. Dann geht ihr auf die Arduino Create Seite:

Arduino Create Seite - die zentrale Schaltstelle - auch für die Arduino SIM Karte
Arduino Create Seite – die zentrale Schaltstelle

Dort geht ihr zum Device Manager –> Add new board –> folgt den Anweisungen. Das gab es alles schon im letzten Beitrag. Nur auf einen kleinen Unterschied möchte ich eingehen, nämlich das Eingeben der SIM Karten Daten:

Eintragen der Arduino SIM Kartendetails
Eintragen der Arduino SIM Kartendetails

Diese Daten sind für alle Arduino SIM Karten gleich und können anscheinend auch nicht geändert werden.

  • APN: prepay.pelion
  • PIN: 0000
  • USER_NAME: arduino
  • PASSWORD: arduino

Zum Abschluss der Installation ladet ihr einen Probesketch hoch, mit dem ihr die On-Board LED an- und ausschalten könnt.

Die Verbindungsqualität mit der Arduino SIM

Ich wohne recht ländlich, mit mittelmäßiger Funkanbindung. Trotzdem funktionierte alles wunderbar auch aus geschlossenen Räumen. Nur die erste Verbindung hat ein wenig auf sich warten lassen. Also nicht gleich aufgeben. 

Ein neues Ding erzeugen

Die Aufgabenstellung für unser Ding habe ich aus dem letzten Beitrag übernommen. Ein DHT22 Sensor soll ausgelesen und eine LED geschaltet werden. Ihr könnt natürlich auch irgendetwas anderes probieren. Idealerweise solltet ihr aber eine Eigenschaft wählen, die ihr steuert und eine andere, die ihr nur auslest.

Der Testsketch

So oder ähnlich sollte der Sketch bei euch aussehen.

#include "thingProperties.h"
#include "DHT.h"

#define LED_PIN 8
#define DHTPIN 7 
#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  // You can of course delete all Serial Monitor Outputs after you've tested everything  
  Serial.begin(9600);
  // This delay gives the chance to wait for a Serial Monitor without blocking if none is found
  delay(1500); 
  dht.begin();
  pinMode(LED_PIN, OUTPUT);

  // Defined in thingProperties.h
  initProperties();

  // Connect to Arduino IoT Cloud
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
    
  setDebugMessageLevel(2);
  ArduinoCloud.printDebugInfo();
}

void loop() {
  static unsigned long lastMeasurement = millis();
  ArduinoCloud.update();
  if((millis() - lastMeasurement) > 3000){
    myTemp = dht.readTemperature(); 
    Serial.print("Temperatur: "); 
    Serial.print(myTemp);
    Serial.println(" C");
    lastMeasurement = millis();
  }
}

void onLedStatusChange() {
    digitalWrite(LED_PIN, ledStatus);
    Serial.print("The light is ");
    if (ledStatus) {
        Serial.println("ON");
    } else {
        Serial.println("OFF");
    }
}

 

Und hier noch die Headerdatei thingProperties.h:

#include <ArduinoIoTCloud.h>
#include <Arduino_ConnectionHandler.h>

const char THING_ID[]      = "e8095xxxxxxxxxxxxxxxxxxxxxxxxxbbc";

const char GPRS_APN[]      = SECRET_APN;
const char PINNUMBER[]     = SECRET_PIN;
const char GPRS_LOGIN[]    = SECRET_USERNAME;
const char GPRS_PASSWORD[] = SECRET_PASSWORD;

void onLedStatusChange();

CloudTemperature myTemp;
bool ledStatus;

void initProperties(){

  ArduinoCloud.setThingId(THING_ID);
  ArduinoCloud.addProperty(myTemp, READ, ON_CHANGE, NULL);
  ArduinoCloud.addProperty(ledStatus, READWRITE, ON_CHANGE, onLedStatusChange);

}

GSMConnectionHandler ArduinoIoTPreferredConnection(PINNUMBER, GPRS_APN, GPRS_LOGIN, GPRS_PASSWORD);

 

Schließlich, der Vollständigkeit halber, noch die dazugehörige Schaltung:

Arduino SIM - Schaltung für den MKR GSM 1400
Arduino SIM – Schaltung für den MKR GSM 1400

Jetzt machen wir unser Ding

Um ein Ding zu erzeugen, haltet ihr euch an die Anweisungen auf den Arduino Seiten. Ihr geht dazu wieder zur Arduino Create Seite –> Arduino IoT Cloud –> ADD NEW THING. Also alles wie gehabt, wie im letzten Beitrag.

Diesmal möchte ich aber noch eine Option zeigen, die ich bisher nur kurz erwähnt hatte. Wenn ihr bei den Properties einen Haken hinter „Show History Visualization“ setzt, könnt ihr die Wertehistorie sehen. Ich habe das mal gemacht und meinen Sensor mit Kältespray heruntergekühlt. So sieht das Ergebnis im Dashboard aus:

Arduino SIM in Action
Arduino SIM in Action – mit Datenhistorie

Datenverbrauch der Arduino SIM Karte

Die 5 MB / Monat, die euch mit der Arduino SIM zur Verfügung gestellt werden, sollten eigentlich für eine ganze Menge Daten reichen. Zu meinem Erstaunen musste ich aber feststellen, dass der Datenverbrauch mit meinem oben abgebildeten Sketch sehr hoch war. Die 5 MB wären in wenigen Tagen verbraucht gewesen.

Der Aufruf von ArduinoCloud.update() findet mit hoher Frequenz statt, da ich kein delay in die Hauptschleife eingefügt habe. Nur alle drei Sekunden gibt es eine Unterbrechung, wenn die Temperatur gemessen wird. Allerdings hatte ich bei der Property Definition der Temperatur angegeben, dass ein Update nur erfolgen soll, wenn das Delta zum zuletzt aktualisierten Wert größer oder gleich 0.1 Grad beträgt. Und da mein Arbeitszimmer recht konstant temperiert ist, sollte sich die Frequenz der Updates in Grenzen halten.

Es scheint also eher an der Größe der übermittelten Datenpakete zu liegen. Der Messwert selbst ist nur ein „Float“ von vier Bytes. Sicherlich wird aber noch die Thing ID mitgeschickt und irgendwelche Dinge für das Übertragungsprotokoll. Eventuell hat auch die Verschlüsselung einen Einfluss. Ein Versuch mit festgelegter Updatefrequenz (also nicht „on change“) ergab, dass pro Update meiner Temperatur um die 600 – 800 Bytes  verbraucht werden. Umgerechnet könnte ich mir ungefähr alle 10 Minuten ein Update leisten. 

Ich habe versucht, in den beteiligen Bibliotheken und Headerdateien nachzuvollziehen, was beim Update eigentlich genau übertragen wird. Dann habe ich mich allerdings darin „verirrt“ und stattdessen im Arduino Forum die Frage nach der Größe der Datenpakete gestellt (bisher ohne Antwort).

Lösungsansätze zum Senken des Datenverbrauchs

Eine Lösung lautet, die Zahl der ArduinoCloud.update() Aufrufe zu begrenzen. In dem Beispielsketch oben könntet ihr z.B. die Funktion mit in die Schleife packen, die dafür sorgt, dass die Temperatur nur alle 3 Sekunden gelesen wird. Allerdings müsstet ihr das Intervall erheblich höher setzen. Nachteilig ist, dass dann auch die LED entsprechend verzögert geschaltet wird.

Oder ihr definiert kein Update „on change“, sondern ein Update „every x seconds“.

Alternativ könntet ihr die ArduinoCloud.update() Funktion nur dann aufrufen, wenn ihr sie wirklich braucht, z.B. bei Überschreiten von Grenzwerten, Auslösen einer Alarmanlage, o. ä. Dann wird es allerdings schwierig mit der Kommunikation in Richtung des Boards, denn ohne Aktualisierung auch kein Schalten….

Auf jeden Fall solltet ihr, zumindest am Anfang, das verbliebene Datenkontingent der Arduino SIM Karte über Arduino Create –> Device Manager regelmäßig prüfen.

Sigfox

Wie schon erwähnt, ist Sigfox zunächst einmal ein französisches Telekommunikationsunternehmen. Sigfox hat ein Funknetz aufgebaut, dass auf der Low-Power Wide-Area Network (LPWAN) Technik basiert und über 868 MHz verbreitet wird. Es wurde insbesondere für IoT Anwendungen, die eine geringe Datenübertragung benötigen, konzipiert. Wenn ihr mehr über das Unternehmen und die Technologie erfahren wollt, dann empfehle ich einen Blick auf diesen Wikipediaeintrag und die Sigfox Webseiten. 

Ich habe in diesen Teil des Beitrages relativ wenig Eigenleistung gesteckt, sondern habe im Wesentlichen die folgenden Anleitungen auf den Arduino Seiten nachvollzogen, übersetzt und etwas modifiziert:

Netzabdeckung prüfen

Bevor ihr Geld für Hardware ausgebt, solltet ihr die Verfügbarkeit des Sigfox Netzes für euren Projektstandort prüfen. Im August 2019 hat Sigfox (laut Sigfox) eine Flächenabdeckung von 85 % in Deutschland erreicht (Link zum Artikel) und es soll noch besser werden.

Am besten prüft ihr die Abdeckung hier nach. Ihr bekommt auf der interaktiven Karte Angaben über die prognostizierte Indoor und Outdoor Verbindungsqualität. Ich habe so weit in die Karte hineingezoomt, dass ich die Netzqualität genau für mein Haus prüfen konnte. Das Ergebnis war: Outdoor – Excellent und Indoor – OK. Die Realität war: Outdoor – grenzwertig, Indoor – ging gar nicht. Ich muss allerdings sagen, dass die Karte für den Bereich „etwas weiter die Straße runter“ tatsächlich eine sehr schlechte Verbindung angab. Setzt also auch mehrere Marker auf der Karte in der Umgebung eures Projektstandortes. Wenn nirgendwo schlechte Ergebnisse auftreten, wäre ich optimistisch, dass es tatsächlich funktioniert.

Netzqualität - li: Voraussage, re: Realität (Outdoor); Link Quality Inidcator (LQI) am Limit - Arduino SIM hat besser funktioniert
Netzqualität – li: Voraussage, re: Realität (Outdoor); Link Quality Inidcator (LQI) am Limit

Das Arduino MKR Fox 1200 Board

Das Arduino MKR Fox 1200 Board

Der MKR Fox 1200 ist derzeit das einzige Arduino Board, das für Sigfox konzipiert wurde.

Auch dieses Board basiert auf dem Low Power Arm® Cortex®-M0 32-bit SAMD21. Bitte achtet deswegen wieder auf die Boardspannung von 3,3 Volt. Ansonsten findet ihr technische Daten zu dem Board hier auf den Arduino Seiten. Darüber hinaus empfehle ich einen Blick in die Getting Started Seiten, sowie in die Funktionen der Low Power Library, die hier beschrieben sind.

Das Board kostet im Arduino Store 35 Euro plus Steuern und Versand (Stand Mai 2020). Darin enthalten ist eine einjährige Nutzung des Sigfox IoT Services mit 140 Nachrichten pro Tag im Wert von 20 Euro. Danach müsst ihr für den Service zahlen. Eine Preisliste für Deutschland findet ihr hier. Der Preis hängt vor allem davon ab, wie viele Nachrichten ihr pro Tag verschicken wollt (2, 50 oder 140). 

Vorbereitungen

Arduino IDE vorbereiten

Zunächst müsst ihr die Arduino IDE vorbereiten. Falls nicht schon geschehen, installiert ihr die Arduino SAMD Boards im Boardverwalter. Dann braucht ihr noch die Bibliotheken „Arduino SigFox for MKRFox1200“ und „Arduino Low Power“, die ihr über die Bibliotheksverwaltung bekommt. 

Sigfox Zugang

Um ein Sigfox Konto zu erhalten, folgt ihr am besten diesem Link und wählt „Apply now“. Zunächst werdet ihr nach dem Firmennamen gefragt, da könnt ihr alternativ euren eigenen Namen angeben. Auch werdet ihr nach eurer Website gefragt – gebt dort irgendetwas ein. Es folgt eine Reihe weiterer, ziemlich neugieriger Fragen, bis ihr hier landet:

Zuvor habt ihr noch eine E-Mail erhalten, mit der ihr euer Passwort setzt. Jetzt könnt ihr die Sigfox Seiten erst einmal verlassen.

Board ID und PAC auslesen

Um eure Board ID und die sogenannte PAC auszulesen, ladet ihr den folgenden Sketch auf den MKR Fox 1200:

#include <SigFox.h>
#include <ArduinoLowPower.h>

void setup() {
  Serial.begin(9600);

  while (!Serial) {};

  if (!SigFox.begin()) {
    Serial.println("Shield error or not present!");
    return;
  }
  String version = SigFox.SigVersion();
  String ID = SigFox.ID();
  String PAC = SigFox.PAC();

  // Display module informations
  Serial.println("MKRFox1200 Sigfox first configuration");
  Serial.println("SigFox FW version " + version);
  Serial.println("ID  = " + ID);
  Serial.println("PAC = " + PAC);

  Serial.println("");

//  Serial.print("Module temperature: ");
//  Serial.println(SigFox.temperatureL()); --> funktionierte nicht bei mir!

  Serial.println("Register your board on https://backend.sigfox.com/activate with provided ID and PAC");

  delay(100);

  // Send the module to the deepest sleep
  SigFox.end();

}

void loop() {
}

 

Die Ausgabe sollte so oder ähnlich aussehen:

ID und PAC auslesen - Ausgabe auf dem seriellen Monitor
ID und PAC auslesen

Die ID ist eine eindeutige Identifikationsnummer für euer Board, die PAC ist eine Art Sicherheitscode für die Registrierung des Boards bei Sigfox. Speichert die Nummern oder notiert sie euch. 

MKR Fox 1200 bei Sigfox registrieren

Nun navigiert ihr zum Backend Bereich von Sigfox und loggt euch mit den zuvor erhaltenen Zugangsdaten ein. Wieder gibt es eine Reihe Fragen. Wählt zunächst das Land aus:

Sigfox Zugang - Auswahl des Landes
Sigfox Zugang – Auswahl des Landes

Jetzt braucht ihr die ID und die PAC. Bei „Tell us about your project“ könnt ihr irgendetwas eingeben (netterweise etwas sinnvolles):

Sigfox ist recht neugierig - mehr Aufwand als bei der Arduino SIM Karte
Sigfox ist recht neugierig

Und noch mehr Fragen. Beim Firmennamen nehmt ihr wieder den eigenen Namen, es sei denn natürlich, ihr habt eine Firma. Dann wählt „Activate your Kit“. Ihr seht euer Board dann in der Device-List:

Dann geht im Menü ganz oben auf DEVICE TYPE, danach klickt auf das N/A unter Keep alive, dann wählt Edit:

Auf der Seite, die jetzt aufgeht, tragt ihr einen Keep-alive Wert ein, z.B. 30 min und ändert den Download Mode auf „DIRECT“. Dann bestätigt mit OK.

Klickt ganz oben auf Device, dann auf eure ID in der Liste. Hier findet ihr Informationen über euer Board. Ihr könnt auch mal auf die anderen Menüpunkte links klicken (Location, Messages, usw.). Das ist allerdings noch nicht so spannend, da ihr noch keine Verbindungen hattet. Später könnt ihr hier wieder zurückkommen. Sigfox fragt viel, erzählt aber auch viel.

Ein erster Test

Geht zurück zur Arduino IDE und ladet den folgenden Sketch auf den MKR Fox 1200:

#include <SigFox.h>
#include <ArduinoLowPower.h>

void setup() {
  Serial.begin(9600);
  while (!Serial) {};

  // Uncomment this line and comment begin() if you are working with a custom board
  //if (!SigFox.begin(SPI1, 30, 31, 33, 28, LED_BUILTIN)) {
  if (!SigFox.begin()) {
    Serial.println("Shield error or not present!");
    return;
  }
  // Enable debug led and disable automatic deep sleep
  // Comment this line when shipping your project :)
  SigFox.debug();

  
  // Send the module to the deepest sleep
  SigFox.end();

  Serial.println("Type the message to be sent");
  while (!Serial.available());

  String message;
  while (Serial.available()) {
    message += (char)Serial.read();
  }

  // Every SigFox packet cannot exceed 12 bytes
  // If the string is longer, only the first 12 bytes will be sent

  if (message.length() > 12) {
    Serial.println("Message too long, only first 12 bytes will be sent");
  }

  Serial.println("Sending " + message);

  // Remove EOL
  message.trim();

  // Example of message that can be sent
  // sendString(message);

  Serial.println("Getting the response will take up to 50 seconds");
  Serial.println("The LED will blink while the operation is ongoing");

  // Example of send and read response
  sendStringAndGetResponse(message);
}

void loop()
{
}

void sendString(String str) {
  // Start the module
  SigFox.begin();
  // Wait at least 30mS after first configuration (100mS before)
  delay(100);
  // Clears all pending interrupts
  SigFox.status();
  delay(1);

  SigFox.beginPacket();
  SigFox.print(str);

  int ret = SigFox.endPacket();  // send buffer to SIGFOX network
  if (ret > 0) {
    Serial.println("No transmission");
  } else {
    Serial.println("Transmission ok");
  }

  Serial.println(SigFox.status(SIGFOX));
  Serial.println(SigFox.status(ATMEL));
  SigFox.end();
}

void sendStringAndGetResponse(String str) {
  // Start the module
  SigFox.begin();
  // Wait at least 30mS after first configuration (100mS before)
  delay(100);
  // Clears all pending interrupts
  SigFox.status();
  delay(1);

  SigFox.beginPacket();
  SigFox.print(str);

  int ret = SigFox.endPacket(true);  // send buffer to SIGFOX network and wait for a response
  if (ret > 0) {
    Serial.println("No transmission");
  } else {
    Serial.println("Transmission ok");
  }

  Serial.println(SigFox.status(SIGFOX));
  Serial.println(SigFox.status(ATMEL));

  if (SigFox.parsePacket()) {
    Serial.println("Response from server:");
    while (SigFox.available()) {
      Serial.print("0x");
      Serial.println(SigFox.read(), HEX);
    }
  } else {
    Serial.println("Could not get any response from the server");
    Serial.println("Check the SigFox coverage in your area");
    Serial.println("If you are indoor, check the 20dB coverage or move near a window");
  }
  Serial.println();

  SigFox.end();
}

 

Im seriellen Monitor gebt ihr eine irgendeine Nachricht von maximal 12 Byte ein. Das ist keine Limitierung des Sketches, sondern eine Limitierung durch Sigfox. Mehr passt nicht rein. Wenn ihr später Sensordaten o. ä. verschicken wollt, könntet ihr z.B. 6 Integerwerte oder 3 Floatwerte unterbringen. Was genau ihr in diesem Test eingebt, ist völlig egal, da ihr noch keine Aktion bei Sigfox definiert habt. 

Die Stunde der Wahrheit: jetzt seht ihr, ob ihr eine Verbindung zu Sigfox aufbauen könnt oder nicht. Wenn alles gut geht, solltet ihr eine Antwort von Sigfox bekommen:

Erfolg - Sigfox antwortet
Erfolg – Sigfox antwortet

Falls die Verbindung nicht funktioniert, könntet ihr mit der Antenne in die Nähe eines Fensters gehen oder es noch einmal draußen versuchen. 

Wenn ihr dann wieder zu Sigfox zu eurem Device zurückkehrt, werdet ihr dort Informationen über die Verbindungsqualität, die Zahl der versendeten Nachrichten und vieles mehr finden. 

Ein Ereignis-Auslöser (Event Trigger)

Jetzt wollen wir Sigfox für uns arbeiten lassen. Das heißt, wenn Sigfox eine Nachricht erhält, soll daraufhin eine bestimmte Aktion folgen. Als simples Beispiel, von hier übernommen, kommen zwei Taster an den MKR Fox 1200. Wird einer der Taster gedrückt, so erfolgt eine Nachricht an Sigfox und Sigfox wiederum soll darüber per E-Mail informieren. 

Einrichtung auf der Sigfox Seite

Geht wieder nach Sigfox in den Backend-Bereich. Geht oben auf der Seite auf Device und dann in der Device-List auf den Eintrag unter Device-Type:

Dann klickt links im Seitenmenü auf Callbacks. Als Nächstes klickt auf „New“ (rechts oben). Danach wählt ihr aus der Liste „Custom callbacks“:

Im nächsten Fenster wählt ihr EMAIL als CHANNEL:

Dann kommt der wichtigste Punkt. Die Struktur eurer Nachrichten tragt ihr in das Feld „Custom payload config“ ein, in diesem Beispiel:

  • str::char:3 boardID::char:8 alarmID::char:1

Das bedeutet, dass die 12 Byte Nachricht folgendermaßen interpretiert werden soll:

  • die Variable „str“ sind die ersten drei Zeichen
  • darauf folgt „boardID“ mit acht Zeichen
  • den Abschluss bildet die „alarmID“ mit einem Zeichen

Ihr seid völlig frei, wie ihr das aufteilt und wie ihr die Variablen benennt, Hauptsache es sind am Ende zwölf Bytes.

Unter Recipient gebt ihr die Ziel-E-Mail-Adresse ein. 

Im Betreff und in der Nachricht könnt ihr dann freien Text schreiben und mit den Variablen anreichern. Für die Variablen verwendet ihr die folgende Schreibweise:

  • {customData#Name_der_Variablen}

Neben dem Variablentyp Char könnt ihr auch verschiedene Integertypen, Floats, Bools, usw. übergeben. Wenn ihr auf das Fragezeichen hinter dem Custom payload config Feld klickt, kommt ihr zu einer Anleitung für die Codierung der Variablen.

Einrichtung auf der Arduino Seite

Auf das MKR Fox 1200 Board ladet ihr den folgenden Sketch:

/*
  SigFox Event Trigger tutorial

  This sketch demonstrates the usage of a MKRFox1200
  to build a battery-powered alarm sensor with email notifications

  A couple of sensors (normally open) should we wired between pins 1 and 2 and GND.

  This example code is in the public domain.
*/

#include <SigFox.h>
#include <ArduinoLowPower.h>

// Set debug to false to enable continuous mode
// and disable serial prints
int debug = true;

volatile int alarm_source = 0;

void setup() {

  if (debug == true) {

    // We are using Serial1 instead than Serial because we are going in standby+
    // and the USB port could get confused during wakeup. To read the debug prints,
    // connect pins 13-14 (TX-RX) to a 3.3V USB-to-serial converter

    Serial1.begin(115200);
    while (!Serial1) {}
  }

  if (!SigFox.begin()) {
    //something is really wrong, try rebooting
    reboot();
  }

  //Send module to standby until we need to send a message
  SigFox.end();

  if (debug == true) {
    // Enable debug prints and LED indication if we are testing
    SigFox.debug();
  }

  // attach pin 0 and 1 to a switch and enable the interrupt on voltage falling event
  pinMode(0, INPUT_PULLUP);
  LowPower.attachInterruptWakeup(0, alarmEvent1, FALLING);

  pinMode(1, INPUT_PULLUP);
  LowPower.attachInterruptWakeup(1, alarmEvent2, FALLING);
}

void loop()
{
  // Sleep until an event is recognized
  LowPower.sleep();

  // if we get here it means that an event was received

  SigFox.begin();

  if (debug == true) {
    Serial1.println("Alarm event on sensor " + String(alarm_source));
  }
  delay(100);

  // 3 bytes (ALM) + 4 bytes (ID) + 1 byte (source) < 12 bytes
  String to_be_sent = "ALM" + SigFox.ID() +  String(alarm_source);

  SigFox.beginPacket();
  SigFox.print(to_be_sent);
  int ret = SigFox.endPacket();

  // shut down module, back to standby
  SigFox.end();

  if (debug == true) {
    if (ret > 0) {
      Serial1.println("No transmission");
    } else {
      Serial1.println("Transmission ok");
    }

    Serial1.println(SigFox.status(SIGFOX));
    Serial1.println(SigFox.status(ATMEL));

    // Loop forever if we are testing for a single event
    while (1) {};
  }
}

void alarmEvent1() {
  alarm_source = 1;
}

void alarmEvent2() {
  alarm_source = 2;
}

void reboot() {
  NVIC_SystemReset();
  while (1);
}

 

Der Sketch (auch den habe ich von den Arduino Seiten übernommen) ist recht einfach verständlich, hat aber ein paar Besonderheiten:

  • Der Sketch nutzt die Low Power Library, um bei batteriebetriebenen Projekten Strom zu sparen, deshalb wird LowPower.attachInterruptWakeUp() anstelle des herkömmlichen attachInterrupt() verwendet. Die Funktion stellt sicher, dass das Board bei Tasterdruck aus dem Sleep Mode aufwacht und der Interrupt ausgelöst wird.
  • Die Schlaffunktion bzw. das Aufwachen könnte den USB-Port irritieren. Deswegen erfolgen die Ausgaben des seriellen Monitors auf Serial1, das sind Pin 13 und 14.
    • Um die Ausgabe auf den seriellen Monitor zu bekommen, müsst ihr einen USB-zu-Seriell Adapter verwenden. So etwas gibt es für ein paar Euro z.B. hier.
  • Wenn ihr den Sketch hochgeladen habt, seht ihr den Port für euer Board nicht mehr in der Arduino IDE. Ihr wechselt auf den Port, an dem der USB-zu-Seriell Adapter hängt. Dann könnt ihr die Debug Ausgaben auf dem seriellen Monitor verfolgen.
  • Sporadisch tauchte der „Board Port“ gar nicht mehr auf. In diesem Fall kann ein Doppelklick auf die Reset Taste des Boards helfen. Notfalls könnt ihr die Sketche auch über den USB-zu-Seriell Adapter hochladen. Auch in diesem Fall macht ihr vorher einen Doppelklick auf die Resettaste.
Die Schaltung für unseren Sigfox Test
Die Schaltung für unseren Sigfox Test

Das Ergebnis

Wenn ihr jetzt auf einen der beiden Taster drückt, erhaltet ihr auf dem seriellen Monitor eine Ausgabe wie die unten abgebildete. Die Error Meldungen bedeuten nicht unbedingt, dass die Nachricht nicht angekommen ist:

Viel entscheidender ist, ob ihr jetzt eine E-Mail wie die folgende bekommen habt:

Sigfox informiert über ein Ereignis
Sigfox informiert über ein Ereignis

Die Zeit (ausgelöst um …) ist eine Sekundenangabe. Der Nullpunkt bezieht sich übrigens auf den Beginn der Unix Epoche am 1. Januar 1970. Näheres zu diesem Thema findet ihr hier. Aber das auch nur am Rande…

Weiteres zum Thema Sigfox

Ich habe mit diesem Beitrag hat nur an der Oberfläche des Sigfox Universums gekratzt. So könntet ihr anstelle von E-Mails die Event-Nachrichten auch an eine Website schicken, um dort einen Status zu aktualisieren. Das hier zu behandeln würde aber zum einen den Rahmen des Beitrags sprengen, zum anderen ist dieser Bereich nicht gerade meine Stärke.

Arduino IoT, Arduino SIM und Sigfox – mein vorläufiges Fazit

Hier nun mein Fazit, das sich auf diesen und den letzten Beitrag bezieht.

Arduino IoT allgemein (über W-LAN oder Kabel)

Positives:

  • Sehr einfach einzurichten
  • Optisch ansprechend (New Dashboards)
  • Erweiterte Möglichkeiten über Webhooks (noch nicht besprochen)
  • Sicherheit ist über die Kryptofunktion auf den Boards gewährleistet

Negatives:

  • Einschränkungen für den kostenfreien Betrieb (Free Plan)
  • Funktioniert nur mit Arduino Boards – und die sind relativ teuer
  • Begrenzte Freiheitsgrade, vorgefertigtes System

Arduino SIM

Positives:

  • Kinderleicht einzurichten
  • W-LAN unabhängig, gute Abdeckung
  • Vertrag jederzeit künd- oder pausierbar

Negatives:

  • funktioniert nur mit dem MKR GSM 1400
  • hohe Anschaffungskosten
  • 5 MB sind schneller ausgeschöpft als erwartet
  • wenig Transparenz hinsichtlich der Größe der Datenpakete

Sigfox

Hier muss ich natürlich sagen, dass ich mich nur über den Zugang über Arduino äußern kann und nicht über Sigfox im Allgemeinen.

Positives:

  • Relativ einfach einzurichten
  • Sehr große Transparenz (Statistiken, Datenverbrauch, usw.)
  • mit dem Kauf eines MKR Fox 1200 ein Jahr umsonst nutzbar

Neutrales:

  • Begrenzung auf 140 Nachrichten, was ca. 1 Nachricht pro 10 Minuten entspricht
    • ob das ausreicht oder nicht hängt vom Projekt ab
    • ist zwar letzten Endes ähnlich wie bei der Arduino SIM, aber immerhin kann man damit exakt planen – bei der Arduino SIM ist das schwieriger

Negatives:

  • Funktioniert nur mit dem MKR Fox 1200 (nochmal: nur bezogen auf den Zugang via Arduino!)
  • Netzabdeckung nicht so zuverlässig prüfbar wie die Prüfung per interaktiver Karte es suggeriert
  • keine Visualisierung von übertragenen Daten (analog zum Arduino IoT Dashboard) – das müsstet ihr komplett selbst gestalten

Ausblick

Was mich selbst – und vielleicht den einen oder anderen von euch auch – bei diesem und dem letzten Beitrag gestört hat, ist die Abhängigkeit von speziellen Boards, die Investitionskosten und ggf. noch laufende Kosten obendrauf. Das ist alles schön einfach, aber es ist zum Teil auch ein recht enges Korsett, das man sich da anzieht.

Im nächsten Beitrag möchte ich beim Thema Internet of Things bleiben. Speziell soll es um das noch nachzuholende Thema Webhooks gehen und wie ihr diese mit dem kostenfreien Service IFTTT (if this then that) nutzen könnt. Das Ganze werde ich vorwiegend am Beispiel des ESP8266 ESP-01 Boards durchspielen, also mal wieder ein kostengünstiges und weit verbreitetes Board.

In einem noch späteren Beitrag (vielleicht der übernächste) werde ich auf GSM Module eingehen, die eine Alternative zur Arduino SIM und Sigfox darstellen können.

Danksagung

Die Gundlage meines Beitragsbildes habe ich jeferrb auf Pixabay zu verdanken.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.