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.
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é.
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
- Organisme du programme
- setup.json
- 3 certificats (rootCA / private / cert)
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.
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.
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