[PYTHON] Envoyer la valeur du capteur d'accélération d'Eaglet + Intel Edison à Kinesis

Cet article est l'article du 20e jour du Calendrier de l'Avent IoT Backend 2015. Créez une application qui envoie la valeur du capteur d'accélération d'Edison au flux Amazon Kinesis comme l'IoT.

1. Préparation du matériel

Intel Edison + Eaglet for Switch Science

L'E / S d'Intel Edison est de 1,8 V, mais comme l'Eaglet dispose d'un circuit de conversion à 3,3 V, de nombreux capteurs du marché peuvent être utilisés. De plus, Eaglet dispose d'un connecteur qui vous permet de connecter GROVE. Donc, je vais utiliser GROVE comme capteur d'accélération.

GROVE - Capteur d'accélération 3 axes I2C ADXL345 installé grove_ ADXL345.png

La connexion est très simple. Connectez simplement les connecteurs Grove les uns aux autres avec le câble fourni avec le capteur. Au contraire, vous pouvez être assuré qu'il ne collera pas.

2. Installez et configurez le logiciel sur Edison

Je ferai la partie de l'article de la dernière fois et de la dernière fois.

Connectez-vous à Edison avec SSH. Installez les packages nécessaires pour développer votre application en Python.

#Installation du gestionnaire de packages Python
root@my-edison:~# opkg install python-pip
#Installation de l'AWS CLI
root@my-edison:~# pip install awscli
#Installer le package Python pour AWS
root@my-edison:~# pip install boto3

Configurez la connexion pour vous connecter à AWS.

root@my-edison:~# aws configure
AWS Access Key ID [None]: <Clé pour Edison>
AWS Secret Access Key [None]: <Clé pour Edison>
Default region name [None]: <Région que vous souhaitez utiliser>
Default output format [None]: <À votre goût>

3. Créer un flux Kinesis

Créez un flux Kinesis pour diffuser les données. Je l'ai créé à partir de l'AWS CLI ici, mais il n'y a pas de problème si je le fais à partir de l'AWS Management Console.

Faites avancer le nom du flux comme Sample-Edison-Stream. Remplacez-le par le nom de votre choix.

$ aws kinesis create-stream --stream-name Sample-Edison-Stream --shard-count 1

Vérifiez si le flux est créé.

$ aws kinesis describe-stream --stream-name Sample-Edison-Stream
{
    "StreamDescription": {
        "RetentionPeriodHours": 24,
        "StreamStatus": "CREATING",
...

Lorsque StreamStatus devient ʻACTIVE`, il est terminé. En cas de «CRÉATION», attendez un moment.

4. Créez une application qui envoie des données à Kinesis

Créez une application qui envoie la valeur du capteur d'accélération à Kinesis environ une fois toutes les 0,1 seconde. Veuillez utiliser l'application créée telle qu'elle est publiée dans le référentiel suivant. https://github.com/mia-0032/edison-adxl345-to-kinesis

Edison a un package appelé upm (Useful Packages & Modules) installé depuis le début, ce qui facilite l'utilisation des capteurs, etc. Tu peux le faire.

`sender.py`


# -*- coding: utf-8 -*-

import boto3
import json
import pyupm_adxl345 as adxl345

from socket import gethostname
from sys import argv
from time import sleep

#Nom du flux Kinesis spécifié par l'argument
stream_name = argv[1]

#Le connecteur Grove d'Eaglet est connecté au I2C n ° 6, spécifiez donc 6.
adxl = adxl345.Adxl345(6)

kinesis = boto3.client('kinesis')

while True:
    #Obtenez une accélération
    adxl.update()
    force = adxl.getAcceleration()
    data = {'X': force[0], 'Y': force[1], 'Z': force[2]}

    #Envoyer des données à Kinesis
    res = kinesis.put_record(
        StreamName=stream_name,
        Data=json.dumps(data),
        PartitionKey=gethostname()  #Cette fois, il n'y a qu'un seul fragment donc ça n'a pas vraiment d'importance
    )

    sleep(0.1)

Il peut être exécuté avec la commande suivante.

root@my-edison:~# python sender.py Sample-Edison-Stream

5. Vérifiez si les données ont été envoyées à Kinesis

Vérifiez si les données circulent vers Kinesis. Nous avons créé un script Python pour confirmation, veuillez donc l'utiliser.

`receiver.py`


# -*- coding: utf-8 -*-

import boto3
import logging

from sys import argv
from time import sleep

#Génération d'enregistreurs
logging.basicConfig()
logger = logging.getLogger()
logger.setLevel(logging.INFO)

#Nom du flux Kinesis spécifié par l'argument
stream_name = argv[1]
logger.info("Stream Name: {0}".format(stream_name))

kinesis = boto3.client('kinesis')

#Obtenir l'ID de fragment
stream = kinesis.describe_stream(
    StreamName=stream_name
)

#Cette fois, puisque le flux est créé avec 1 partition, le premier ID de partition est utilisé.
shard_id = stream['StreamDescription']['Shards'][0]['ShardId']

#Obtenez le premier itérateur de partition
shard_iterator = kinesis.get_shard_iterator(
    StreamName=stream_name,
    ShardId=shard_id,
    ShardIteratorType='TRIM_HORIZON'
)['ShardIterator']

#Obtenez des enregistrements sérieusement en boucle
while True:
    res = kinesis.get_records(
        ShardIterator=shard_iterator,
        Limit=100
    )
    for r in res['Records']:
        logger.info(
            'Time: {0}, Data: {1}'.format(
                r['ApproximateArrivalTimestamp'],
                r['Data']
            )
        )
    shard_iterator = res['NextShardIterator']
    sleep(1)

Il peut être exécuté avec la commande suivante.

root@my-edison:~# python receiver.py Sample-Edison-Stream

Si le record coule comme ça, c'est une réussite.

INFO:root:Time: 2015-12-20 14:40:59.522000+09:00, Data: {"Y": -0.10188677161931992, "X": -0.075471684336662292, "Z": 0.95703125}
INFO:root:Time: 2015-12-20 14:40:59.675000+09:00, Data: {"Y": -0.056603759527206421, "X": 0.0037735840305685997, "Z": 0.94921875}
INFO:root:Time: 2015-12-20 14:40:59.833000+09:00, Data: {"Y": -0.24150937795639038, "X": 0.018867921084165573, "Z": 0.90625}
INFO:root:Time: 2015-12-20 14:40:59.983000+09:00, Data: {"Y": -0.22264145314693451, "X": -0.0037735840305685997, "Z": 0.9296875}
INFO:root:Time: 2015-12-20 14:41:00.133000+09:00, Data: {"Y": -0.15094336867332458, "X": 0.011320752091705799, "Z": 0.9375}

Vous avez envoyé avec succès les données à Kinesis! Vive le bon travail.