Verfolgen Sie Gerätedaten in Echtzeit mit Vonage Messages API und Ubidots

Ich betrachte das Internet der Dinge (IoT) als einen Superhelden: Es ist meist unsichtbar, aber es macht unser Leben bei der Arbeit, in der Gesellschaft und im Privatleben besser. Superhelden haben die enorme Kraft, überall dort für Sie da zu sein, wo Sie sie brauchen, sei es in Städten, Krankenhäusern, Bildungseinrichtungen, Produktionsstätten, Bauernhöfen oder an jedem anderen Ort, den Sie sich vorstellen können. Klingt sehr nach dem Internet der Dinge, finden Sie nicht auch?

Versetzen wir uns einmal in die Lage von Natalia. Natalia arbeitet im landwirtschaftlichen Sektor mit Schwein Visioneiner intelligenten Kamera, die künstliche Intelligenz und neuronale Netze integriert. Mit diesem Gerät kann sie Echtzeitdaten über den Wiegevorgang in den Betrieben erhalten, ohne die Schweine zu belasten. Was aber, wenn Natalia auf die Daten zugreifen muss, aber in diesem Moment keinen Internetzugang hat? Hier kommt die Vonage Messages API Hier kommt die Vonage Messages API ins Spiel - was, wenn Natalia die benötigten Daten per SMS anfordert?

Heutzutage gibt es zahlreiche Messaging-Dienste und Visualisierungsplattformen, die die Technologie für jedermann zugänglich machen; man muss kein erfahrener Ingenieur sein, um innovative Lösungen zu entwickeln. Darüber hinaus ermöglichen diese Dienste die Bereitstellung kompletter Lösungen innerhalb weniger Stunden. Ausgehend von Natalias Anwendungsfall und allen datenbasierten Anforderungen, die in verschiedenen Branchen bestehen können, dachte ich, es wäre großartig, ein System zu haben, das in der Lage ist, Gerätedaten unabhängig vom Internetzugang in Echtzeit zu überwachen.

In diesem Tutorial zeige ich Ihnen detaillierte Schritte zum Aufbau dieses Systems unter Verwendung der Vonage Messages API als Nachrichtendienst und Ubidots als IoT-Plattform. Als Ausgangspunkt sollten wir die zu implementierende Architektur verstehen:

illustration of architecture

Die Integration dieser Dienste erfolgt über eine UbiFunction, einer Serverless Computing-Umgebung, die es uns ermöglicht, die an unsere virtuelle Nummer gesendete Nachricht über eine HTTP-Anfrage zu empfangen. Wir sind dann in der Lage, sie zu analysieren, um die Geräte und die angeforderten Variablen zu identifizieren, um den letzten für jede angeforderte Variable erhaltenen Wert als Antwort zu senden.

Zweifelsohne wird dieses System für verschiedene Anwendungsfälle nützlich sein. Sie müssen nur ein wenig kreativ werden, um herauszufinden, wo es für das Projekt, an dem Sie arbeiten, nützlich sein kann. Ohne weitere Umschweife, fangen wir an!

Voraussetzungen

• Ubidots Account

• Jedes Gerät mit Internetzugang

Vonage API-Konto

Um dieses Tutorial durchzuführen, benötigen Sie ein Vonage API-Konto. Wenn Sie noch keines haben, können Sie sich noch heute anmelden und mit einem kostenlosen Guthaben beginnen. Sobald Sie ein Konto haben, finden Sie Ihren API-Schlüssel und Ihr API-Geheimnis oben auf dem Vonage-API-Dashboard.

In diesem Lernprogramm wird auch eine virtuelle Telefonnummer verwendet. Um eine zu erwerben, gehen Sie zu Rufnummern > Rufnummern kaufen und suchen Sie nach einer Nummer, die Ihren Anforderungen entspricht.

Sind Sie bereit, mit dem Bau zu beginnen?

Erleben Sie nahtlose Konnektivität, Echtzeit-Messaging und kristallklare Sprach- und Videoanrufe - alles auf Knopfdruck.

IoT-Plattform einrichten

Mit Ubidots können Sie IoT-Applikationen schnell zusammenstellen und starten, ohne viele Zeilen Code schreiben zu müssen - es ist einfach und dennoch leistungsstark. Um mit der Nutzung zu beginnen, benötigen wir lediglich einen Account und ein beliebiges Gerät mit einer Internetverbindung, um Daten an die Ubidots-API.

Gerät einrichten

Für dieses Projekt habe ich eine Pycon SiPy und PySense 1verwendet, mit dem wir Umgebungsvariablen wie Temperatur, Feuchtigkeit, Lichtintensität und Druck überwachen können. Wenn Sie jedoch eine andere Hardware haben, die HTTP, MQTT, oder TCP/UDP als Kommunikationsprotokoll kann es ebenfalls integriert werden. Sie können das Ubidots Hilfe-Center finden Sie Anleitungen, wie Sie mit einem beliebigen IoT-Gerät Daten an die Plattform senden und von ihr steuern können.

Das Pycom-Team fügt jede Woche neue Funktionen zu seinen Produkten hinzu. Bevor Sie also mit der Entwicklung beginnen, sollten Sie sicherstellen, dass Ihr Board mit der aktuellen letzten Firmware-Update. Wenn Sie Windows als Betriebssystem verwenden, müssen Sie außerdem die erforderlichen Treiber installieren.

*HINWEIS: Wenn Sie zum ersten Mal mit Pycom-Karten entwickeln, empfehle ich Ihnen dringend, sich die Einsteigerhandbuch um sich mit allen Details vertraut zu machen.*

Installieren Sie Pymakr, ein Plug-in, das für Atom und Visual Studio Codeum Projekte auf jedem Pycom-Board auszuführen und zu synchronisieren. Pymakr fügt auch eine REPL-Konsole zu dem Terminal hinzu, das mit dem Board verbunden ist.

Als nächstes stellen Sie die Kommunikation zwischen Pymakr und Ihrem Board über Seriell oder Telnet her, je nachdem, was Sie bevorzugen. Schauen Sie sich die Setup-Anleitungen für Ihren Code-Editor an:

• Atom

• Visual Studio-Code

Code

Dieses Projekt erfordert einige externe Bibliotheken, die heruntergeladen und an einem Ort zentralisiert werden müssen, um ordnungsgemäß zu funktionieren. Wenn Sie sie alle zusammen mit dem Hauptcode herunterladen möchten, können Sie hier herunterladen.

Wenn Sie ganz von vorne anfangen möchten, erstellen Sie ein neues Projekt mit einem Namen Ihrer Wahl. Ich habe mich für den Namen **_pysense-ubidots-mqtt_**.

In dem **_pysense-ubidots-mqtt_** Projekt werden wir die erforderlichen Bibliotheken verwalten und den Hauptcode hinzufügen. Dazu erstellen Sie einen neuen Ordner namens **_lib_**sowie eine neue Datei namens **_main.py_**

Aus dem pycom-Bibliotheken-Repositoryladen Sie die folgenden Bibliotheken herunter und legen Sie sie in den **_lib_** soeben erstellten Ordner:

• PySense

• LTR329ALS01

• MPL3115A2

• SI7006A20

• PyCoproc

• umqtt.einfach

• umqtt.robuts

Nach dem Herunterladen dieser Bibliotheken sollten Sie die folgende Struktur im Projektordner haben:

- lib
    - LTR329ALS01.py
    - MPL3115A2.py
    - pycoproc.py
    - pysense.py
    - SI7006A20.py
    - umqtt
        - robust.py
        - simple.py
- main.py

Diese Bibliotheken ermöglichen uns die Kommunikation mit der Hauptplatine (in meinem Fall SiPy), mit dem PySense und die Verwaltung der Daten mit Ubidots über MQTT.

Kopieren Sie den folgenden Code in die Datei main.py Datei. Dieser Code veröffentlicht ständig Temperatur-, Luftfeuchtigkeits-, Druck- und Höhenwerte an Ubidots:

#!/usr/bin/python

# Include Libraries
from umqtt.robust import MQTTClient
import machine
import time
import pycom
import json
import ubinascii
from network import WLAN
from pysense import Pysense
from LIS2HH12 import LIS2HH12
from SI7006A20 import SI7006A20
from LTR329ALS01 import LTR329ALS01
from MPL3115A2 import MPL3115A2,ALTITUDE,PRESSURE
import gc
gc.collect()

# Define network constants
wifi_ssid = "xxxx" # Set Network's SSID
wifi_password = "xxxx" # Set Network password

# Define Ubidots constants
mqtt_server = "industrial.api.ubidots.com" # 169.55.61.243
mqtt_clientID = ubinascii.hexlify(machine.unique_id(),'').decode()
mqtt_username = "BBFF-xxxx" # Set your Ubidots TOKEN
ubidots_dev_label = "weather-station" # ubinascii.hexlify(machine.unique_id(),':').decode() # Set a device labe

# Constants to manage data rate
last_message = 0
message_interval = 5

'''
Establishes connection with the MQTT server defined
'''
def connect_mqtt():
  global mqtt_clientID, mqtt_server
  client = MQTTClient(mqtt_clientID, mqtt_server, user=mqtt_username, password=mqtt_username)
  client.connect()
  print("\nConnected to {} MQTT broker".format(mqtt_server))
  return client


'''
Reset the device to restore the connection with the MQTT Server
'''
def restart_and_reconnect():
  print("\nFailed to connect to MQTT broker. Reconnecting...")
  time.sleep(10)
  machine.reset()


'''
Establish network connection
 @arg ssid [Mandatory] Network SSID
 @arg psw [Mandatory] Network Password
'''
def wifi_connect(ssid, psw):
  attempts = 0

  print("Starting attempt to connect to WiFi.", end="")
  wlan.connect(ssid, auth=(WLAN.WPA2, psw), timeout=5000) # Connect to the WiFi AP provided

  # Check network status
  while not wlan.isconnected():
    time.sleep(0.5)
    print(".", end="")
    attempts += 1
    machine.idle() # Safe power while waiting

    if attempts >= 10:
      print("\nssid: {}, psw: {}".format(wifi_ssid, wifi_password))
      print("\nCould not establish connection with the network provided. Please check the network crendentials or status, and try again.");
      time.sleep(0.5)
      attempts = 0
      machine.reset()

  # Network interface parameteres logs
  network_settings =  wlan.ifconfig()
  print("\nWLAN connection succeeded!")
  print("IP address: {}".format(network_settings[0]))
  print("Subnet: {}".format(network_settings[1]))
  print("Gateway: {}".format(network_settings[2]))
  print("DNS: {}".format(network_settings[3]))

  return True

'''
Reads temperature, humidity, pressure, altitude, and light sensors
 @return data, JSON object with sensors readings
'''
def read_sensors():
  # Barometric sensor constructor (Pressure (Pascals), Altitud (meters), Temperature (celsius ))
  mpl_pressure = MPL3115A2(py, mode=PRESSURE)
  mpl_altitude = MPL3115A2(py,mode=ALTITUDE)
  # Humidity & Temperature sensor constructor (Humidity (relative humidity), Temperature (celsius))
  si = SI7006A20(py)
  # Ambient light sensor consturctor (Light levels(luxes))
  ltr = LTR329ALS01(py)
  # Sensors readings
  pressure = mpl_pressure.pressure()
  altitude = mpl_altitude.altitude()
  temperature_mpl = mpl_altitude.temperature()
  temperature_si = si.temperature()
  relative_humidity = si.humidity()
  ambient_humidty = si.humid_ambient(temperature_si)
  dewpoint = si.dew_point()
  light = ltr.light()

  # Readings logs
  print("\nMPL3115A2 | Pressure: {} Pa, Altitude: {} m, Temperature: {} ºC".format(pressure, altitude, temperature_mpl))
  print("SI7006A20 | Temperature: {} ºC, Relative Humidity: {} %RH, Ambient Humidity: {} %RH, Dew point: {}".format(temperature_si, relative_humidity, ambient_humidty, dewpoint))
  print("LTR329ALS01 | Light (channel Blue lux, channel Red lux): {}\n".format(light))
  # JSON build
  data = b'{ "pressure" : %s,"altitude" : %s, "temp_mpl" : %s, "temp_si" : %s, "rel_hum" : %s, "amb_hum" : %s, "dew_point" : %s, "lux_blue" : %s, "lux_red" : %s }' % (pressure, altitude, temperature_mpl, temperature_si, relative_humidity, ambient_humidty, dewpoint, light[0], light[1])

  return data


# Network's inizalitation
wlan = WLAN(mode=WLAN.STA) # Set STA (Station Aka Client, connects to an AP) as WLAN network interface 'STA_IF' (Station aka client, connects to upstream WiFi Access points)
wlan.antenna(WLAN.EXT_ANT) # Set antenna type (INT_ANT: Internal, EXT_ANT: External)
wifi_connect(wifi_ssid, wifi_password)

# Sensors' inizalitation
py = Pysense()

# Establishes connection with the MQTT server
try:
  client = connect_mqtt()
except OSError as e:
  restart_and_reconnect()

# Main function
while True:
  try:
    # Network reconnection
    if wlan.isconnected() != True:
      wifi_connect(wifi_ssid, wifi_password)

    # Publish sensor data every 5 seconds
    if (time.time() - last_message) > message_interval:
      data = read_sensors()
      client.publish(b"/v1.6/devices/%s" % (ubidots_dev_label), data)
      last_message = time.time()

  except OSError as e:
    restart_and_reconnect()

Anstatt nur zu kopieren und einzufügen, können wir uns auch ansehen, wie der Code funktioniert. Zunächst müssen die erforderlichen Bibliotheken importiert werden:

from umqtt.robust import MQTTClient
import machine
import time
import pycom
import json
import ubinascii
from network import WLAN
from pysense import Pysense
from LIS2HH12 import LIS2HH12
from SI7006A20 import SI7006A20
from LTR329ALS01 import LTR329ALS01
from MPL3115A2 import MPL3115A2,ALTITUDE,PRESSURE
import gc

In den folgenden Variablen weisen wir dann die Netzwerkanmeldeinformationen zu, um die Verbindung herzustellen:

wifi_ssid = "xxxx"
wifi_password = "xxxx"

Um die Kommunikation mit einem Ubidots Account über MQTT herzustellen, müssen wir die Broker-Adresse sowie den Client und den Benutzernamen für die Authentifizierung der Kommunikation definieren:

• MQTT-Broker: industrial.api.ubidots.com oder 169.55.61.243.

• MQTT-KlientClient: eindeutiger Bezeichner für die Client-Server-Kommunikation. Es wird empfohlen, die MAC-Adresse des Geräts als Bezeichner für den Client zu verwenden, da dies ein eindeutiger Wert pro Gerät ist.

• MQTT-Benutzername: Authentifizierung für die Kommunikation mit dem Broker. Im Fall von Ubidots müssen wir das Account-Token als Benutzernamen zuweisen.

mqtt_server = "industrial.api.ubidots.com" # 169.55.61.243
mqtt_clientID = ubinascii.hexlify(machine.unique_id(),'').decode()
mqtt_username = "BBFF-xxxx" # Set your Ubidots TOKEN

Als nächstes weisen Sie die Geräteetikett. Dieses Label ist die eindeutige Kennung, die es uns ermöglicht, mit Ubidots zu kommunizieren, entweder um Daten zu veröffentlichen oder um Daten zu/von einem Thema zu abonnieren. Es kann ein eindeutiger Wert oder die MAC-Adresse des Geräts sein. In meinem Fall habe ich weather-station als Gerätelabel zugewiesen:

ubidots_dev_label = "weather-station"

Um die Deklarationen abzuschließen, weisen Sie die gewünschte Datenrate als message_interval. Die Variable ist standardmäßig auf fünf Sekunden eingestellt. Die Variable last_message speichert das letzte Mal, dass eine Nachricht gesendet wurde.

last_message = 0
message_interval = 5

Nun ist es an der Zeit, das Board mit dem lokalen Netzwerk zu verbinden. Zuerst erstellen wir ein WLAN Netzwerkschnittstellen-Objekt. Wie Sie unten sehen können, wird das Objekt unter der wlan erstellt und ist so konfiguriert, dass es die externe Antenne verwendet, da ich das Gerät etwas weiter weg vom Router aufgestellt habe. Wenn Sie die interne Antenne verwenden möchten, verwenden Sie einfach wlan.antenna(WLAN.INT_ANT).

wlan = WLAN(mode=WLAN.STA)
wlan.antenna(WLAN.EXT_ANT)

Dann stellt die Funktion wifi_connect() die Kommunikation mit dem angegebenen Netz auf:

wifi_connect(wifi_ssid, wifi_password)

Aber was genau tut die wifi_connect Funktion? Wie Sie unten sehen können, übernimmt sie die Aufgabe, die Netzwerkverbindung herzustellen, und gibt die Netzwerkparameter nur zurück, wenn die Verbindung erfolgreich hergestellt wurde. Im Falle eines Problems wird dieses gemeldet, und das Gerät wird neu gestartet, um die Verbindung erneut zu versuchen.

def wifi_connect(ssid, psw):
  attempts = 0

  print("Starting attempt to connect to WiFi.", end="")
  wlan.connect(ssid, auth=(WLAN.WPA2, psw), timeout=5000)

  while not wlan.isconnected():
    time.sleep(0.5)
    print(".", end="")
    attempts += 1
    machine.idle()

    if attempts >= 10:
      print("\nssid: {}, psw: {}".format(wifi_ssid, wifi_password))
      print("\nCould not establish connection with the network provided. Please check the network crendentials or status, and try again.");
      time.sleep(0.5)
      attempts = 0
      machine.reset()

  network_settings =  wlan.ifconfig()
  print("\nWLAN connection succeeded!")
  print("IP address: {}".format(network_settings[0]))
  print("Subnet: {}".format(network_settings[1]))
  print("Gateway: {}".format(network_settings[2]))
  print("DNS: {}".format(network_settings[3]))

  return True

Dann initialisieren Sie das PySense-Board als py

py = Pysense()

Um Kommunikationsprobleme mit dem Broker zu vermeiden, wird die Verbindung hergestellt, bevor die while. Sollte jedoch ein Kommunikationsproblem auftreten, wird die umqtt Bibliothek eine automatische Wiederherstellung der Verbindung. Falls die Verbindung aus einem anderen Grund nicht hergestellt werden kann, z. B. weil der Broker nicht erreichbar ist, wird die Karte neu gestartet, um zu versuchen, die Verbindung erneut herzustellen.

try:
  client = connect_mqtt()
except OSError as e:
  restart_and_reconnect()

Die Funktion connect_mqtt() öffnet eine neue MQTT-Verbindung zu dem angegebenen Broker:

def connect_mqtt():
  global mqtt_clientID, mqtt_server
  client = MQTTClient(mqtt_clientID, mqtt_server, user=mqtt_username, password=mqtt_username)
  client.connect()
  print("\nConnected to {} MQTT broker".format(mqtt_server))
  return client

Wie Sie unten sehen können, ist der Hauptcode für drei Prozesse zuständig.

Überprüfen Sie zunächst die Netzwerkverbindung:

if wlan.isconnected() != True:
      wifi_connect(wifi_ssid, wifi_password)

Veröffentlichen Sie dann alle 5 Sekunden Sensordaten an Ubidots:

    if (time.time() - last_message) > message_interval:
      data = read_sensors()
      client.publish(b"/v1.6/devices/%s" % (ubidots_dev_label), data)
      last_message = time.time()

Hier ist die Funktion read_sensors() die Aufgabe, Messwerte von allen Sensoren zu erfassen und eine JSON-Nutzlast zu erstellen, die an Ubidots gesendet wird:

def read_sensors():
  mpl_pressure = MPL3115A2(py, mode=PRESSURE)
  mpl_altitude = MPL3115A2(py,mode=ALTITUDE)
  si = SI7006A20(py)
  ltr = LTR329ALS01(py)

  pressure = mpl_pressure.pressure()
  altitude = mpl_altitude.altitude()
  temperature_mpl = mpl_altitude.temperature()
  temperature_si = si.temperature()
  relative_humidity = si.humidity()
  ambient_humidty = si.humid_ambient(temperature_si)
  dewpoint = si.dew_point()
  light = ltr.light()

  print("\nMPL3115A2 | Pressure: {} Pa, Altitude: {} m, Temperature: {} ºC".format(pressure, altitude, temperature_mpl))
  print("SI7006A20 | Temperature: {} ºC, Relative Humidity: {} %RH, Ambient Humidity: {} %RH, Dew point: {}".format(temperature_si, relative_humidity, ambient_humidty, dewpoint))
  print("LTR329ALS01 | Light (channel Blue lux, channel Red lux): {}\n".format(light))
  # JSON build
  data = b'{ "pressure" : %s,"altitude" : %s, "temp_mpl" : %s, "temp_si" : %s, "rel_hum" : %s, "amb_hum" : %s, "dew_point" : %s, "lux_blue" : %s, "lux_red" : %s }' % (pressure, altitude, temperature_mpl, temperature_si, relative_humidity, ambient_humidty, dewpoint, light[0], light[1])

  return data

Starten Sie schließlich die Karte neu, wenn ein Fehler beim Broker auftritt:

except OSError as e:
    restart_and_reconnect()

Die Funktion restart_and_reconnect() startet das Board neu, um die Verbindung mit dem Broker wiederherzustellen.

def restart_and_reconnect():
  print("\nFailed to connect to MQTT broker. Reconnecting...")
  time.sleep(10)
  machine.reset()

Sobald Sie den Code in Pymakr haben, können Sie den Code in das Board hochladen, indem Sie auf die Schaltfläche Hochladen Knopf drücken. Warten Sie ein paar Sekunden, bis das Gerät die Kompilierung abgeschlossen hat.

Gehen Sie im Ubidots Account zu Geräte > Geräte und sehen Sie, wie ein weather-station Gerät automatisch erstellt wurde, sobald die Sensordaten empfangen wurden:

Ubidots New Device

OPTIONAL Ubidots ermöglicht es uns, Geräte und Variablen mit freundlichen Namen, Farben, Symbolen und Beschreibungen zu versehen. Beachten Sie jedoch, dass die Beschriftungen der Geräte und Variablen nicht geändert werden können, da die Beschriftung für die Kommunikation zwischen den Geräten und der Plattform zuständig ist.

In meinem Fall habe ich die Variablen Namen, Icons, Einheitenund Farben.

Vor der Anpassung:

Ubidots Generic Device

Nach der Anpassung:

Ubidots Custom Device

Dashboard einrichten

Eines der Dinge, die ich bei der Arbeit mit Ubidots liebe, sind die eingängigen Visualisierungen, die sie anbieten. Außerdem gibt es eine große Auswahl an Widgets, mit denen Sie das Aussehen Ihres Dashboards vollständig anpassen können. Dashboards sind ein sehr wichtiger Teil von IoT-Lösungen, da wir von überall auf der Welt auf alle Daten unserer Geräte zugreifen können, aber... nur, wenn wir eine Internetverbindung haben.

Um ein Dashboard zu erstellen, navigieren Sie zum Abschnitt Daten > Dashboard_Abschnitt. Klicken Sie dann auf _Neues Dashboard und vergeben Sie den gewünschten Namen.

Um neue Widgets hinzuzufügen, klicken Sie einfach auf das blaue Plus-Symbol, wählen Sie den Widget-Typ aus und legen Sie einige Anpassungen für die Visualisierung fest. Jetzt ist es an der Zeit, kreativ zu werden und die verschiedenen Widgets, die Ubidots anbietet, zu erkunden.

So sieht mein Armaturenbrett aus!

Ubidots Dashboard

Für weitere Informationen zu Dashboards und Widget-Einstellungen empfehle ich Ihnen, die folgenden Anleitungen zu lesen:

• Dashboards und Widgets erstellen

• Branding der Anwendung: Benutzerdefinierte Stile für Ihre Dashboards und Widgets

Vonage-Einrichtung

Dank der Vonage Messages APIkönnen wir auf einfache Art und Weise verschiedene Messaging-Strategien aktivieren. Sie ermöglicht nicht nur den Versand von SMSzu versenden, sondern ermöglicht auch die Kommunikation über verschiedene Kanäle wie MMS, Whatsapp, Facebook Messenger, und Viber. Für dieses Projekt werde ich den SMS-Kanal verwenden, da ich demonstrieren möchte, wie man Daten anfordert, wenn man keinen Internetzugang hat.

Gehen wir wie folgt vor, um unseren Vonage Account einzurichten:

1. Greifen Sie auf Ihr Vonage-Konto zu. Falls Sie noch keins haben, melden Sie sich und beginnen Sie noch heute mit dem Aufbau.

2. Sobald Sie angemeldet sind, finden Sie den API-Schlüssel und API-Geheimnis für Ihren Account am oberen Rand des Vonage-API-Dashboard. Diese Anmeldedaten werden benötigt, um die Kommunikation mit externen Diensten wie Ubidots herzustellen. Beachten Sie, dass diese Anmeldeinformationen immer sicher aufbewahrt und niemals weitergegeben werden sollten.

3. Erstellen Sie eine neue Anwendung. Sie können dies über das Vonage API Dashboard tun - gehen Sie einfach zu unsere Applications > + Neue Applikation erstellen und vergeben Sie einen Namen für die Anwendung - oder indem Sie Senden einer HTTP-Anfrage. Um diese Anleitung benutzerfreundlich zu gestalten, habe ich mich entschlossen, dies direkt über das Dashboard zu tun. Sie brauchen nur ein paar Klicks zu machen, einen Namen zu vergeben, und das war's!

4. Um eingehende Nachrichten zu empfangen, müssen Sie eine virtuelle Nummer. Die Nummer können Sie über das Entwickler-Dashboard, Nexmo CLIoder API.

5. Verknüpfen Sie die gemietete Nummer mit der zuvor erstellten Anwendung, indem Sie auf den verknüpfen. im Nummernbereich der Anwendung klicken.

Vonage Virtual Number

Integration von Vonage und Ubidots

Gehen Sie im Ubidots Account auf die Seite Gerät > Funktionen und klicken Sie auf das Plus-Symbol oben rechts auf der Seite, um eine neue Funktion zu erstellen. Um die Funktion zu erstellen, müssen Sie die folgenden Parameter zuweisen:

• Name: Vonage Messages API

• HTTP-Methode: POST

• Laufzeit: NodeJs 10

*HINWEIS: Die UbiFunction kann auch in Python programmiert werden, aber der Code in diesem Leitfaden ist in NodeJS.

Sobald Sie konfiguriert sind, drücken Sie die Aktivieren Schaltfläche. An diesem Punkt wird das Feld HTTPS Endpoint URL automatisch mit dem Endpunkt ausgefüllt, der die Nachrichten von Vonage empfangen wird.

In meinem Fall war die generierte URL: https://parse.ubidots.com/prv/{ubidots_username}/vonage-messages-api.

Navigieren Sie dann im Vonage-Entwicklerportal zu den Einstellungen zu, klicken Sie auf Ihren Benutzernamen und weisen Sie dann die folgenden Parameter unter der Option Standard-SMS-Einstellung Option zu. Zum Schluss speichern Sie die Änderungen.

• Lieferscheine: HTTPS Endpunkt URL generiert + /webhooks/delivery-receipts:

https://parse.ubidots.com/prv/{ubidots_username}/vonage-messages-api/webhooks/delivery-receipts

• Eingehende Nachrichten: HTTPS Endpoint URL generiert + /webhooks/inbound-message:

https://parse.ubidots.com/prv/{ubidots_username}/vonage-messages-api/webhooks/inbound-message

• HTTP-Methode: POST

Wenn eine Nachricht an die virtuelle Nummer gesendet wird, leitet sie die Informationen an diesen Endpunkt weiter.

Gehen Sie nun zurück zu der erstellten UbiFunction und ersetzen Sie den Standardcode durch den unten stehenden Code:

// Import the 'request-promise' library to handle HTTP requests
var request = require("request-promise");

// Ubidots constants
const UBIDOTS_TOKEN = "BBFF-xxxx";
// Vonage constants
const VONAGE_API_SECRET = "xxxxxx";

/*
 * Main function - runs every time the UbiFunction is executed
 *
 * @arg args, dictionary containing Vonage request data
 */
async function main(args) {
  // When sending SMS, delivery receipts will be returned
  // status: submitted, delivered,
  if (args["status"]) {
    return args;
  }

  // Parses incoming values
  var api_key = args["api-key"];
  var keyword = args["keyword"];
  var msisdn = args["msisdn"];
  var text = args["text"];
  var to = args["to"];
  var msg_type = args["type"];
  //var message_timestamp = args['message-timestamp'];
  //var messageId = args['messageId'];

  // Verify the keyword received to request the data
  if (keyword == "UBIDOTS") {
    text = text.toLowerCase(); // Converts the text received to lowercase letters

    // Filter the requested devices
    const devices = /Devices:(.*)/i.exec(text);
    const deviceList = devices[1].split(",").map((device) => device.trim());
    // Filter the requested variables
    const variables = /Variables:(.*)/i.exec(text);
    const variableList = variables[1]
      .split(",")
      .map((variable) => variable.trim());

    // "msg" stores the response to be sent
    var msg = "Data requested:\n";

    // Iterates the deviceList previously filtered
    for (const device of deviceList) {
      msg = msg.concat("\nDevice: ", device);
      // Iterates the variableList previously filtered
      for (const variable of variableList) {
        // Handle GET request to Ubidots
        try {
          var response = await ubidots_get_request(
            UBIDOTS_TOKEN,
            device,
            variable
          );
          msg = msg.concat("\nVariable: ", variable, " = ", response);
        } catch (error) {
          // Send a reply back in case any error is presented
          var vonage_response = await vonage_messages(
            api_key,
            msg_type,
            msisdn,
            to,
            "The requested data cannot be found. Please verify it and try again."
          );
          // Pass the error message caught as the function's response
          return { message: error.message };
        }
      }
      msg = msg.concat("\n");
    }
  }

  // Send a reply back with the requested data
  /*  Reply example for multiple devices and variables:
  
      Data requested:

      Device: balcony
      Variable: humidity = 50.87
      Variable: temperature = 36.39

      Device: kitchen
      Variable: humidity = 55.72
      Variable: temperature = 29.45
  */
  //var vonage_response = await vonage_messages(api_key, msg_type, msisdn, to, msg);
  var vonage_response = await vonage_messages(
    api_key,
    msg_type,
    msisdn,
    to,
    msg
  );

  // Pass Vonage's API Response as the function's reponse
  return vonage_response;
}

/*
 * Handle an HTTP POST request to Vonage Messaging API
 * API Documentation: https://developer.nexmo.com/api/messages-olympus#overview
 *
 * @arg api_key [Mandatory], Nexmo account's API Key
 * @arg msg_channel [Mandatory], type of message that you want to send.
 * @arg recipient [Mandatory], phone number of the message recipient
 * @arg sender [Mandatory], phone number of the message sender
 * @arg msg [Mandatory], text of the message
 *
 * @return message_uuid, UUID of the message
 */

async function vonage_messages(api_key, msg_type, recipient, sender, msg) {
  // Base64 encoded API key and secret joined by a colon
  var auth =
    "Basic " +
    Buffer.from(api_key + ":" + VONAGE_API_SECRET).toString("base64");

  var options = {
    method: "POST",
    url: "https://api.nexmo.com/v0.1/messages",
    headers: {
      Authorization: auth,
      "Content-Type": "application/json",
      Accept: "application/json",
    },
    json: {
      from: {
        type: "sms",
        number: sender,
      },
      to: {
        type: "sms",
        number: recipient,
      },
      message: {
        content: {
          type: msg_type,
          text: msg,
        },
      },
    },
  };

  // Pass UUID of the message sent
  return await request.post(options);
}

/*
 * Handle an GET request to Ubidots API
 * API Documentation: https://ubidots.com/docs/sw/
 *
 * @arg token [Mandatory], Ubidots account's Token
 * @arg device_label [Mandatory], single and unique label of device
 * @arg variable_label [Mandatory], single and unique label of variable
 *
 * @return last_value, variable last value
 */
async function ubidots_get_request(token, device_label, variable_label) {
  var options = {
    method: "GET",
    url:
      "https://industrial.api.ubidots.com/api/v1.6/devices/" +
      device_label +
      "/" +
      variable_label +
      "/lv",
    json: true,
    headers: {
      "Content-Type": "application/json",
      "X-Auth-Token": token,
    },
  };

  var last_value = await request.get(options);

  return last_value;
}

/*
 * Handle an POST request to Ubidots API
 * API Documentation: https://ubidots.com/docs/sw/
 *
 * @arg token [Mandatory], Ubidots account's Token
 * @arg device_label [Mandatory], single and unique label of device
 * @arg variable_label [Mandatory], single and unique label of variable
 *
 * @return last_value, variable last value
 */
async function ubidots_post_request(token, label, body) {
  var options = {
    method: "POST",
    url: "https://industrial.api.ubidots.com/api/v1.6/devices/" + label,
    body: body,
    json: true,
    headers: {
      "Content-Type": "application/json",
      "X-Auth-Token": token,
    },
  };

  var response = await request.post(options);

  return response;
}

Dann müssen wir die Konstante UBIDOTS_TOKEN durch die Konstante Ubidots TOKENund die VONAGE_API_SECRET mit dem Vonage-API-Geheimnis um die Kommunikation zwischen der UbiFunction und beiden Diensten zu ermöglichen.

// Ubidots constants
const UBIDOTS_TOKEN = "BBFF-xxxx";
// Vonage constants
const VONAGE_API_SECRET = "xxxxxx";

Vergessen Sie nicht, die Taste Live schalten um die vorgenommenen Änderungen zu speichern!

Der bereitgestellte Code ist für jeden seiner Prozesse und Funktionen ausführlich kommentiert, so dass das Verständnis nicht allzu schwierig sein sollte. Lassen Sie uns jedoch aufzeigen, wie er funktioniert:

• Der UbiFunction-Hauptcode ist für den Empfang der von Vonage gesendeten Nutzdaten zuständig, wenn eine neue SMS gesendet oder ein anderer SMS-Status gemeldet wird.

• Anschließend wird die empfangene SMS analysiert, um den API-Schlüssel, das Schlüsselwort, die empfangene SMS und den Absender zu identifizieren.

• Wenn das empfangene Schlüsselwort gleich Ubidots ist, wird der empfangene Text gefiltert, um eine Liste der abzufragenden Geräte und Variablen zu erstellen.

• Die erstellten Listen werden iteriert, um den letzten Wert jeder der Variablen an Ubidots abzufragen.

• Die angeforderten Daten werden zu einer Zeichenkette verkettet, die als Antwort an den Absender gesendet wird, sobald alle Daten korrekt angefordert wurden.

Damit die Abfrage von Daten per SMS zufriedenstellend erfolgt, müssen wir die folgenden Vorlagen verwenden:

• Für ein einzelnes Gerät:

SMS-Anfrage:

Ubidots request data
Devices: {device_label}
Variables: {variable_label_1}, {variable_label_2}, {variable_label_n}

SMS Antwort:

Data requested:

Device: {device_label}
Variable: {variable_label_1} = 23
Variable: {variable_label_2} = 246
Variable: {variable_label_n} = 85

• Für mehrere Geräte:

SMS-Anfrage:

Ubidots request data
Devices: {device_label_1}, {device_label_2}, {device_label_n}
Variables: {variable_label_1}, {variable_label_2}, {variable_label_n}

SMS Antwort:

Data requested:

Device: {device_label_1}
Variable: {variable_label_1} = 23
Variable: {variable_label_2} = 246
Variable: {variable_label_n} = 85

Device: {device_label_2}
Variable: {variable_label_1} = 23
Variable: {variable_label_2} = 246
Variable: {variable_label_n} = 85

Device: {device_label_n}
Variable: {variable_label_1} = 23
Variable: {variable_label_2} = 246
Variable: {variable_label_n} = 85

*WICHTIGER HINWEIS: Mehrere Geräteanfragen werden nur für Geräte unterstützt, die dieselben Variablen enthalten.*

Um zu überprüfen, ob alles richtig funktioniert, senden wir zwei Nachrichten an die gemietete Nummer, eine mit dem erstellten Gerät (weather-station) und eine weitere mit einem Gerät, das nicht existiert, um die Antworten zu unterscheiden:

Anfrage #1:

Ubidots request data
Devices: weather-station
Variables: dew_point, lux_blue, amb_hum, temp_mpl

Anfrage #2:

Ubidots request data
Devices: ws
Variables: dew_point, lux_blue, amb_hum, temp_mpl

Es gingen folgende Antworten ein:

Satisfactory reply

Device not found

Wie erwartet, funktioniert es richtig! Wenn wir nun die empfangenen Werte mit den Werten unseres Dashboards vergleichen, können wir feststellen, dass sie übereinstimmen:

Ubidots Final Dashboard

Nachbereitung und nächste Schritte

Wenn wir über das Internet der Dinge sprechen, denken wir zuerst an das Internet, aber in Wirklichkeit gibt es andere Alternativen, die es uns ermöglichen, auf diese Daten zuzugreifen, auch wenn wir einmal keinen Zugang zum Internet haben.

In diesem Leitfaden haben wir alles behandelt, was Sie wissen müssen, um mit der Vonage Messages API und Ubidots zu kommunizieren und Daten über eine SMS abzufragen. Sie können diese Entwicklung jedoch erweitern und an jede beliebige IoT-Anwendung anpassen, die Ihnen vorschwebt, sei es eine Anwendung zur Steuerung der Beleuchtung zu Hause, Community-Netzwerke für Sensoren, ein benutzerdefinierter Chatbot und vieles mehr.

Darüber hinaus können Sie die anderen Kanäle erkunden, die von der Vonage Messages APIIch bin mir ziemlich sicher, dass Sie damit die Arbeit an Ihrem nächsten Superhelden beginnen können :)