Python simulé pour essayer AWS IoT Device Shadow

introduction

Je pense que l'une des raisons d'utiliser AWS IoT est que vous pouvez contrôler Thing / Device by Thing shadow. Par contre, bien que j'aie compris le schéma, beaucoup de gens pensent qu'il n'est pas possible de vérifier l'opération car il n'y a pas de "Chose". Vous pouvez en fait vérifier cela sous Linux en utilisant le SDK de périphérique. Ici, vérifions le fonctionnement de Thing shadow en utilisant EC2 comme périphérique virtuel.

[Une addition] J'ai été interrogé sur la signification de Shadow, alors j'ajouterai un peu. Si vous gérez un appareil comme cet exemple, il n'est pas difficile de l'organiser manuellement, mais dans le cas de l'IoT, il est nécessaire de gérer un grand nombre de capteurs et de passerelles. De plus, ce n'est pas toujours proche. Je pense que la valeur de l'ombre est que vous pouvez gérer / modifier les paramètres de nombreux appareils distants via le cloud.

Préparation

AWS IoT

Créer une chose

Sélectionnez le registre et sélectionnez des éléments. Lorsque le volet Thing apparaît, appuyez sur créer en haut de l'écran. スクリーンショット 2017-02-07 23.08.11.png

Pour créer une chose, définissez un nom arbitraire et appuyez sur créer une chose. Ici, thinname est _ ** shadow-test ** _.

Sélectionnez Certificat sur l'écran après avoir créé Thing. Appuyez sur créer un certificat sur l'écran affiché. スクリーンショット 2017-02-07 23.11.03.png

Veuillez télécharger les trois certificats créés. (cert.pem / public.key / private.key) Appuyez également sur ** Actif ** affiché en bas de l'écran pour activer le certificat.

Confirmer le point de terminaison

Sur la console AWS IoT, appuyez sur Paramètres en bas à gauche de l'écran, vérifiez le point de terminaison sur l'écran affiché, copiez-le dans du texte, etc. Il existe un point de terminaison pour chaque région. {random}.iot.{region}.amazon.com Il est affiché sous la forme de.

EC2

Démarrer EC2

Démarrez Amazon Linux avec EC2. t2.micro suffit. Si vous ne savez pas comment démarrer EC2, veuillez consulter ici. La taille du disque dur est également suffisante par défaut. N'oubliez pas de configurer Global IP pour vous connecter avec SSH.

Installer le SDK des appareils IoT sur EC2

Puisque la simulation est faite avec le SDK python, installez le SDK Python. Émettez la commande suivante à partir de la console EC2

pip install AWSIoTPythonSDK

Installation du programme factice (maquette)

Comme requis

Endroit Dans cet article, je suppose que vous travaillerez sous / tmp.

mkdir /tmp/dummy-shadow
cd /tmp/dummy-shadow
mkdir certs
cd certs

Paramètres de certificat

Obtenir rootCA (placé sous les certificats) Obtenu auprès de VeriSign ici

curl https://www.symantec.com/content/en/us/enterprise/veisign/roots/VeriSign-Class%203-Public-Primary-Certification-Authority-G5.pem -o /tmp/root.pem

Placez également le certificat privé / cert créé précédemment dans AWS IoT dans ce répertoire certs. Vous pouvez également copier et coller avec scp / vi. Le nom du fichier est cert => cert.pem private => private.pem S'il vous plaît. Essayez d'obtenir le résultat suivant.

ls -1 /tmp/certs
cert.pem
private.pem
root.pem

Installation de mannequin (maquette)

Placez les fichiers suivants dans / tmp / dummy-shadow. Veuillez définir YOUR_AWSIOT_DOMAIN en fonction de votre environnement. Pour la vérification du domaine, consultez Paramètres de la console AWS IoT => Point de terminaison personnalisé.

setup.json


{
   "AWSIoT": {
        "ENDPOINT":"YOUR_AWSIOT_DOMAIN",
        "CERT_PATH":"./certs/",
        "KEYS":["cert.pem", "public.pem", "root.pem"]
   },
   "DEVICE":{
        "NAME":"shadow-test",
   }
}

Ci-dessous le programme factice

dummy-shadow.py


import os
import sys
import json
import time
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTShadowClient


CONFIG_FILE = './setup.json'

#Correction de la définition de l'état au démarrage de l'application(Variables qui se synchronisent avec l'ombre)
SIGNAL    = "green"
WAIT_TIME = 10

#Comme shadow est lu à partir de la fonction de rappel, il est défini comme global.
shadow         = None
shadow_hundler = None

##########################################################
# setup.Lire les paramètres de json
##########################################################
def readConfig():
    print 'start readConfig func'

    try:
        # read config file
        f = open(CONFIG_FILE, "r")
        jsonData = json.load(f)
        f.close()

        list = {}
        list["ENDPOINT"]    = jsonData["AWSIoT"]["ENDPOINT"]
        list["CERT_PATH"]   = jsonData["AWSIoT"]["CERT_PATH"]
        list["DEVICE_NAME"] = jsonData["DEVICE"]["NAME"]
        
        return list

    except Exception as e:
        print 'Config load error'
        print e.message
        sys.exit()

##########################################################
#Émission de la commande de mise à jour Shadow
##########################################################
def updateThing(report):
    try: 
        report_json = '{"state":{"reported":'+ report + '}}'
        print "send currnet status to cloud-shadow"
        print report_json
        shadow_hundler.shadowUpdate(report_json, None, 5)
        
        return
    
    except Exception as e:
        print e.message
        sys.exit()
        
##########################################################
#Appelé comme type de rappel à partir de shadowRegisterDeltaCallback
#
##########################################################
def getDelta(payload, responseStatus, token):
    try:
        print '======get Delta======'
        dict_delta = json.loads(payload)
        print dict_delta
        state = dict_delta["state"]
        
        if state.has_key("wait_time"):
            delta = int(state["wait_time"])
            global WAIT_TIME
            WAIT_TIME = delta
            print "wait time change :%s" % WAIT_TIME
        if state.has_key('signal'):
            global SIGNAL
            SIGNAL = state['signal']
            print "SIGNAL change :%s" % SIGNAL

        report = json.dumps(dict_delta["state"])
        updateThing(report)
        
        return

    except Exception as e:
        print "Error on Delta function"
        print e.message
        raise

################################################
#Fonction procédurale de connexion d'ombre
################################################
def initShadow(Config):
    ##--need device cert / private / rootCA--
    # rootCA: get from symantec
    ROOT_KEY    = Config['CERT_PATH'] + 'root.pem'
    CERT_KEY    = Config['CERT_PATH'] + 'cert.pem'
    PRIVATE_KEY = Config['CERT_PATH'] + 'private.pem'
    
    try:
        # init shadow connect procedure
        global shadow
        shadow = AWSIoTMQTTShadowClient(Config["DEVICE_NAME"])
        shadow.configureEndpoint(Config["ENDPOINT"], 8883)    # Setting URL-ENDPOINT & Port
        shadow.configureCredentials(ROOT_KEY, PRIVATE_KEY, CERT_KEY ) # Cert file setting
        shadow.configureConnectDisconnectTimeout(10)# CONNACK wait time (sec)
        shadow.configureMQTTOperationTimeout(5)     # QoS1 publish (sec)
        print 'start connct shadow'
        shadow.connect()
        print 'shadow connect'
        
        return
    
    except Exception as e:
        print 'Error on Init Shadow'
        raise
        
####
if __name__ == '__main__':
    Config = readConfig()
    
    try:
        initShadow(Config)
        print 'satrt subscribe shadow'
        shadow_hundler = shadow.createShadowHandlerWithName(Config['DEVICE_NAME'], True)
        shadow_hundler.shadowRegisterDeltaCallback(getDelta)
        default_state = '{"wait_time":' + str(WAIT_TIME) + ', "signal":"green"}'
        updateThing(default_state)

        while True:
            time.sleep(WAIT_TIME)
            print 'Currnet WAIT_TIME=%s' % str(WAIT_TIME)
            pass

    except KeyboardInterrupt:
         print 'Keyboard Interrupt'
         sys.exit()

    except Exception as e:
        print e.message
        sys.exit()

Méthode d'exécution

python PROGRAM.py &

Commence en arrière-plan avec.

shadow update

Effectuez la mise à jour de l'ombre sur la console ou la CLI Sélectionnez Resistor => Thing => [Thing Name] => Shadow.

Ajoutez une section souhaitée comme indiqué ci-dessous et enregistrez-vous avec wait_time: 30, signal: "green". Ensuite, en tant que delta, wait_time: 30, c'est-à-dire que seule la différence est rapportée à la chose comme delta.

スクリーンショット 2017-02-19 22.20.44.png

Si vous regardez la console côté programme, vous devriez voir le delta et la semelle. Donc, comme vous pouvez le voir dans le code, j'ai changé la variable wait_time et renvoyé [state]. Étant donné que l'état qui devrait être la cohérence du résultat est écrit dans l'état delta, il n'est pas nécessaire de créer JSON un par un simplement en le signalant lorsque __ transition d'état correct __ est effectuée. Comme mentionné ci-dessus, veuillez noter que si vous signalez dans un état où l'état ne peut pas être modifié correctement, il sera mal aligné.

Lorsque ce rapport est envoyé, le delta doit avoir disparu et souhaité / signalé doit avoir la même valeur.

Séquence approximative

La séquence approximative est illustrée ci-dessous.

スクリーンショット 2017-02-19 22.38.16.png

Codé en dur comme état du rapport au démarrage du programme SIGNAL = "green" WAIT_TIME = 10 Sera notifié. Si l'état de l'ombre est changé plusieurs fois, les paramètres initiaux ci-dessus seront notifiés immédiatement après le démarrage du programme et delta sera reçu immédiatement.

Avertissement

Ce poste est une opinion individuelle et n'est pas lié à l'entreprise ou à l'organisation à laquelle il appartient. De plus, nous ne garantissons pas le fonctionnement de l'exemple de programme affiché, veuillez donc l'utiliser comme référence uniquement.

Recommended Posts

Python simulé pour essayer AWS IoT Device Shadow
Essayez de comprendre Python soi
Script pour créer facilement un environnement de périphérique client pour AWS IoT (version Python v2)
Exécutez AWS IoT Device SDK for Python sur Raspberry Pi
[AWS] Essayez d'ajouter la bibliothèque Python à la couche avec SAM + Lambda (Python)
Essayez d'exploiter Facebook avec Python
Essayez de calculer Trace en Python
Essayez de convertir la CLI cloudmonkey en python3 -1
[AWS SAM] Présentation de la version Python
Essayez de reproduire un film couleur avec Python
Essayez de vous connecter à qiita avec Python
Essayez Python
Je veux jouer avec aws avec python
Essayez d'utiliser Excel en utilisant Python (Xlwings)
Python amateur tente de résumer la liste ①
Surveillance active des appareils AWS IoT
Connectez-vous à s3 avec AWS Lambda Python
Premiers pas pour essayer Google CloudVision en Python
Essayez d'implémenter Oni Mai Tsuji Miserable avec python
Essayez d'envoyer des métriques à datadog via python, DogStatsD
Calculons en fait le problème statistique avec Python
3.14 π jour, alors essayez de sortir en Python
Essayez auto pour évaluer automatiquement Enum dans Python 3.6
[Version 2020] Comment installer Python3 sur EC2 d'AWS
Essayez de résoudre le diagramme homme-machine avec Python
Essayez de dessiner une courbe de vie avec python
Essayez de créer un code de "décryptage" en Python
Essayez de générer automatiquement des documents Python avec Sphinx
Comment spécifier des attributs avec Mock of Python
Essayez de calculer RPN avec Python (pour les débutants)
Essayez de créer un groupe de dièdre avec Python
[AWS / Lambda] Comment charger une bibliothèque externe Python
Premiers pas avec AWS IoT facilement en Python
Résumé de l'étude de Python pour utiliser AWS Lambda
Essayez de détecter les poissons avec python + OpenCV2.4 (inachevé)
Mis à jour vers Python 2.7.9
Python> essayez: / sauf:
Essayez d'exécuter Schedule pour démarrer et arrêter des instances dans AWS Lambda (Python)
"Backport" vers python 2
Essayez de résoudre le livre des défis de programmation avec python3
python débutant essaie d'ajouter une authentification de base à l'administrateur de Django
Essayez de créer un module Python en langage C
[Python] Essayez de lire la bonne réponse au problème FizzBuzz
Faisons un outil de veille de commande avec python
Essayez d'améliorer votre propre quiz d'introduction avec Python
Provisionnement de flotte avec AWS IoT SDK for Python v2
(Python) Essayez de développer une application Web en utilisant Django
Essayez de résoudre le problème d'affectation du médecin de formation avec Python
Essayez le fonctionnement de la base de données avec Python et visualisez avec d3
Définissez les arguments mot-clés du constructeur sur les attributs fictifs en Python
termux × AWS Envoyez des informations de localisation de smartphone à AWS avec l'IoT
Je veux écrire en Python! (3) Utiliser des simulacres
Je veux AWS Lambda avec Python sur Mac!
Essayez d'extraire des mots à haute fréquence en utilisant NLTK (python)
Raspberry Pi + python + appareil IoT, procédure de construction d'environnement pour démarrer le traitement d'image et l'apprentissage automatique