introduction

Watson IoT Platform (Internet of Things Platform, ci-après WIOTP) est une plateforme pour l'IoT basée sur IBM Cloud. Il fournit diverses fonctions telles que la collecte, l'accumulation et la visualisation de données obtenues à partir d'appareils tels que des capteurs. Un SDK officiel est fourni pour connecter des appareils et des applications, et les données peuvent être envoyées et reçues via MQTT. Cet article explique comment procéder.

Concept de plateforme Watson IoT

Tout d'abord, j'expliquerai le concept de «choses» géré par WIOTP. WIOTP définit les trois types suivants de «choses» à connecter, et les fonctions et méthodes de connexion qui peuvent être implémentées diffèrent pour chacun.

--Application --Dispositif --Passerelle

application

L'application peut utiliser la plupart des fonctionnalités des trois éléments, recevoir des événements envoyés depuis l'appareil et les utiliser pour des services, ou envoyer des événements en tant qu'appareil seul. Afin de l'implémenter en tant qu'application, il est nécessaire d'émettre une clé API dans la console WIOTP à l'avance. En s'authentifiant avec la clé API lors de la connexion à WIOTP, l'application connectée peut être identifiée par WIOTP. De plus, WIOTP définit le type d'application à prendre en compte et vous pouvez limiter les fonctions qui peuvent être utilisées en sélectionnant le type d'application pour chaque clé API.

Vous pouvez utiliser les fonctionnalités suivantes dans votre application: --Recevoir les événements envoyés depuis votre appareil --Envoyer des commandes à l'appareil --Envoyer des événements en tant qu'appareil --Recevoir des commandes en tant que périphérique

dispositif

Le rôle de l'appareil est d'envoyer les informations environnantes obtenues par le capteur etc. au WIOTP. Afin de l'implémenter en tant que périphérique, il est nécessaire de définir à l'avance le type et l'ID de périphérique dans la console WIOTP, et de définir l'ID de périphérique de manière à ce qu'il soit unique pour chaque périphérique. WIOTP vous permet d'identifier quel appareil a effectué la demande de connexion ou la transmission de données par ID d'appareil.

Les fonctionnalités suivantes sont disponibles sur votre appareil: --Envoyer un événement à l'application, tel que "Une personne a été détectée par un capteur humain" --Recevoir les commandes envoyées par l'application

passerelle

Lorsqu'il existe plusieurs appareils du même type et du même rôle, le rôle de la passerelle est de relayer les données entre eux et WIOTP. Ce faisant, WIOTP peut réellement traiter les données envoyées à partir de plusieurs appareils comme si elles avaient été envoyées à partir d'un seul appareil (passerelle), ce qui facilite le traitement des données. Comme pour les appareils, la passerelle doit définir le type d'appareil et l'ID d'appareil à l'avance sur la console WIOTP. Il est traité comme l'un des périphériques dans WIOTP.

Les fonctionnalités suivantes sont disponibles sur la passerelle: --Recevoir les événements envoyés par l'appareil et les relayer à l'application

Recevoir les commandes envoyées par l'application et les relayer vers l'appareil

Créer un échantillon

Nous utiliserons en fait le SDK officiel pour créer un exemple d'application qui envoie et reçoit régulièrement des événements à WIOTP. Cette fois, nous allons créer l'expéditeur en tant qu'appareil et le destinataire en tant qu'application.

supposition

Vous avez un compte IBM Cloud
Vous avez déjà créé une instance de Watson IoT Platform sur IBM Cloud.

Préparation préalable

Paramètres de l'appareil dans WIOTP

Enregistrez l'appareil requis pour mettre en œuvre l'appareil.

--Ouvrez une instance de Watson IoT Platform et ouvrez "Devices" dans le menu sur le côté gauche de l'écran. ――La page indiquant "Rechercher un appareil" s'affiche. Cliquez sur le bouton "Ajouter un appareil" en haut à droite.

--Définissez n'importe quelle valeur pour "Type de périphérique" et "ID de périphérique", puis cliquez sur le bouton "Suivant".

Sur la page suivante, cliquez simplement sur le bouton "Suivant" sans rien saisir.
La page "Jeton d'authentification généré automatiquement" s'affiche. Le "jeton d'authentification" peut être généré automatiquement ou défini sur n'importe quelle valeur. Après le réglage, cliquez sur le bouton "Suivant".

--L'écran de résumé s'affiche.Cliquez sur le bouton "Terminer".

L'enregistrement du périphérique est terminé lorsque la page "Device Drilldown" s'affiche. Notez les informations affichées ici car vous les utiliserez plus tard.

Émission de la clé API dans WIOTP

Émettez la clé API nécessaire pour implémenter l'application. Pour plus d'informations, reportez-vous à «1. Émission de clés API» dans l'article suivant. https://qiita.com/Motonaga/items/6304f5f66f63cb566943

Implémentation de l'expéditeur

Implémentez le périphérique d'envoi.

`publish.py`


import wiotp.sdk.application
import time
import json

##Incorporer divers paramètres pour "appareil" définis dans WIOTP dans les informations de configuration au format JSON (options)
org_id = "xxxx" #ID d'organisation WIOTP
device_id = "sample_id" #"Device ID" défini à l'avance
device_type = "sample_type" #"Type d'appareil" défini à l'avance
token = "sample-token" #"Jeton d'authentification" défini à l'avance
event_id = "sample" #L'identifiant de l'événement à envoyer. Toute valeur peut être définie. Donnez-lui la même valeur que le côté récepteur

options = {
  "identity": {
    "orgId": org_id,
    "typeId": device_type,
    "deviceId": device_id
  },
  "auth": {
    "token": token
  }
}

#Connectez-vous à WIOTP en tant que "périphérique" à l'aide du SDK
client = wiotp.sdk.device.DeviceClient(options,  logHandlers=None)
client.connect()

#Toutes les 2 secondes{count}Est incrémenté et envoyé au WIOTP
myData = {'message': 'foo', 'count': 0}
while True:
  print("data published: ", json.dumps(myData))
  client.publishEvent(event_id, "json", myData)
  myData['count'] += 1
  time.sleep(2)

Mise en œuvre du bénéficiaire

Implémentez l'application de réception.

`subscribe.py`


import wiotp.sdk.application
import json
import time

app_id = "sample_app" #Identifiant D'application. Définissez n'importe quelle valeur
app_auth_key = "xxxx" #Clé API de l'application émise par WIOTP
app_auth_token = "xxxx" #Jeton d'authentification d'application émis par WIOTP

#Incorporer divers paramètres pour «application» définis dans WIOTP dans les informations de configuration au format JSON (options)
options = {
  "identity": {
    "appId": app_id
  },
  "auth": {
    "key": app_auth_key,
    "token": app_auth_token
  }
}

#Connectez-vous à WIOTP en tant qu '«application» à l'aide du SDK
client = wiotp.sdk.application.ApplicationClient(options, logHandlers=None)
client.connect()

#Définissez la fonction de rappel lorsqu'un événement est reçu. Ici, les informations d'événement reçues sont écrites sur la sortie standard.
def event_callback(event):
  #Le corps des données reçues est un événement.Peut être obtenu avec des données
  print("{} event '{}' received from device [{}]: {}".format(event.format, event.eventId, event.device, json.dumps(event.data)))
client.deviceEventCallback = event_callback

#Définissez les paramètres de l'appareil auquel vous souhaitez vous abonner (les mêmes que ceux de l'expéditeur) et démarrez S'inscrire
device_id = "sample_id" #"Device ID" défini à l'avance
device_type = "sample_type" #"Type d'appareil" défini à l'avance
event_id = "sample" #L'identifiant de l'événement à recevoir. Toute valeur peut être définie. Donnez-lui la même valeur que l'expéditeur

client.subscribeToDeviceEvents(typeId=device_type, deviceId=device_id, eventId=event_id)

#Exécutez une boucle pour que l'application reste opérationnelle
while True: 
  time.sleep(3)

Résultat d'exécution

Si vous exécutez à la fois l'expéditeur et le destinataire, vous obtiendrez les résultats suivants et vous pourrez confirmer que les données peuvent être envoyées et reçues via MQTT comme prévu.

Console de l'appareil WIOTP (affiche le contenu des événements envoyés)

Réception de la console

$ python subscribe.py 
2019-12-23 15:41:58,308   wiotp.sdk.application.client.ApplicationClient  INFO    Connected successfully: a:a54k3u:sample_app
json event 'sample' received from device [sample_type:sample_id]: {"message": "foo", "count": 0}
json event 'sample' received from device [sample_type:sample_id]: {"message": "foo", "count": 1}
json event 'sample' received from device [sample_type:sample_id]: {"message": "foo", "count": 2}
json event 'sample' received from device [sample_type:sample_id]: {"message": "foo", "count": 3}
json event 'sample' received from device [sample_type:sample_id]: {"message": "foo", "count": 4}
json event 'sample' received from device [sample_type:sample_id]: {"message": "foo", "count": 5}
json event 'sample' received from device [sample_type:sample_id]: {"message": "foo", "count": 6}

Résumé

Dans cet article, j'ai expliqué le concept de «choses» qui se connectent à Watson IoT Platform et expliqué comment se connecter à l'aide du SDK officiel. En ce qui concerne la méthode de connexion, j'ai créé l'expéditeur en tant qu'appareil et le récepteur en tant qu'application, mais lorsque je l'utilise dans le domaine réel, je pense qu'il y aura de nombreuses implémentations dans lesquelles plusieurs appareils seront relayés par la passerelle.

Matériel de référence

Github: https://github.com/ibm-watson-iot/iot-python
Python SDK: https://ibm-watson-iot.github.io/iot-python/
Documentation officielle: https://cloud.ibm.com/docs/services/IoT?topic=iot-platform-connect_devices_apps_gw&locale=ja --Premier MQTT: https://gist.github.com/voluntas/89000a06a7b79f1230ab

[PYTHON] Envoyez et recevez des données avec MQTT via Watson IoT Platform