Inserisci dati per AWS IoT SiteWise from AWS IoT things

Passare alla console AWS IoT SiteWise.

Nel riquadro di navigazione a sinistra scegliere Models (Modelli).

Scegli Crea modello di asset.

In Dettagli del modello, inserisci un nome per il tuo modello. Ad esempio, SiteWise Tutorial Device Model.

In Measurement definitions (Definizioni misurazione), effettuare le seguenti operazioni:

1. In Nome, inserisci CPU Usage.

2. In Unit (Unità), immettere %.

3. Lasciare Data type (Tipo di dati) come Double (Doppio).

Le proprietà di misurazione rappresentano i flussi di dati non elaborati di un dispositivo. Per ulteriori informazioni, consulta Definire i flussi di dati provenienti dalle apparecchiature (misurazioni).

Scegli Aggiungi nuova misura per aggiungere una seconda proprietà di misurazione.

Nella seconda riga sotto Measurement definitions (Definizioni misurazione), effettuare le seguenti operazioni:

1. In Nome, inserisci Memory Usage.

2. In Unit (Unità), immettere %.

3. Lasciare Data type (Tipo di dati) come Double (Doppio).

In Metric definitions (Definizioni parametri), effettuare le seguenti operazioni:

1. In Nome, inserisci Average CPU Usage.

2. In Formula (Formula), immettere avg(CPU Usage) . Scegliere CPU Usage dall'elenco di completamento automatico quando viene visualizzato.

3. In Time interval (Intervallo di tempo), immettere 5 minutes.

Le proprietà dei parametri definiscono i calcoli di aggregazione che elaborano tutti i punti dati di input per un intervallo e generano un singolo punto dati per ogni intervallo. Questa proprietà dei parametri calcola l'utilizzo medio della CPU di ogni dispositivo ogni 5 minuti. Per ulteriori informazioni, consulta Aggrega i dati provenienti da proprietà e altre risorse (metriche).

Scegli Aggiungi nuova metrica per aggiungere una seconda proprietà della metrica.

Nella seconda riga sotto Metric definitions (Definizioni parametri), effettuare le seguenti operazioni:

1. In Nome, inserisci Average Memory Usage.

2. In Formula (Formula), immettere avg(Memory Usage) . Scegliere Memory Usage dall'elenco di completamento automatico quando viene visualizzato.

3. In Time interval (Intervallo di tempo), immettere 5 minutes.

Questa proprietà dei parametri calcola l'utilizzo medio della memoria di ogni dispositivo ogni 5 minuti.

(Facoltativo) Aggiungere altri parametri che devono essere calcolati per ogni dispositivo. Alcune funzioni interessanti sono min e max. Per ulteriori informazioni, consulta Usa espressioni di formula. Nella fase 4: Creazione di un modello di asset del parco dispositivi, crei una risorsa principale in grado di calcolare le metriche utilizzando i dati dell'intero parco dispositivi.

Scegli Crea modello.

Passare alla console AWS IoT SiteWise.

Nel riquadro di navigazione a sinistra scegliere Models (Modelli).

Scegli Create asset model.

In Dettagli del modello, inserisci un nome per il tuo modello. Ad esempio, SiteWise Tutorial Device Fleet Model.

In Hierarchy definitions (Definizioni gerarchie), effettuare le seguenti operazioni:

1. In Hierarchy name (Nome gerarchia), immettere Device.

2. Nel Hierarchy model (Modello gerarchia), scegliere il modello di asset dispositivo (SiteWise Tutorial Device Model).

Una gerarchia definisce una relazione tra un modello di asset padre (parco istanze) e un modello di asset figlio (dispositivo). Gli asset padre possono accedere ai dati delle proprietà degli asset figlio. Quando si creano gli asset in un secondo momento, è necessario associare gli asset figlio agli asset padre in base a una definizione di gerarchia nel modello di asset padre. Per ulteriori informazioni, consulta Le gerarchie degli asset rappresentano le relazioni tra le apparecchiature.

In Metric definitions (Definizioni parametri), effettuare le seguenti operazioni:

1. In Nome, inserisci Average CPU Usage.

2. In Formula (Formula), immettere avg(Device | Average CPU Usage) . Quando viene visualizzato l'elenco di completamento automatico, selezionare Device per scegliere una gerarchia, quindi selezionare Average CPU Usage per scegliere il parametro dall'asset dispositivo creato in precedenza.

3. In Time interval (Intervallo di tempo), immettere 5 minutes.

Questa proprietà del parametro calcola l'utilizzo medio della CPU di tutti gli asset dispositivo associati a un asset parco istanze tramite la gerarchia Device.

Scegli Aggiungi nuova metrica per aggiungere una seconda proprietà della metrica.

Nella seconda riga sotto Metric definitions (Definizioni parametri), effettuare le seguenti operazioni:

1. In Nome, inserisci Average Memory Usage.

2. In Formula (Formula), immettere avg(Device | Average Memory Usage) . Quando viene visualizzato l'elenco di completamento automatico, selezionare Device per scegliere una gerarchia, quindi selezionare Average Memory Usage per scegliere il parametro dall'asset dispositivo creato in precedenza.

3. In Time interval (Intervallo di tempo), immettere 5 minutes.

Questa proprietà del parametro calcola l'utilizzo medio della memoria di tutti gli asset dispositivo associati a un asset parco istanze tramite la gerarchia Device.

(Facoltativo) Aggiungere altri parametri che devono essere calcolati per il parco istanze dei dispositivi.

Scegli Crea modello.

Passare alla console AWS IoT SiteWise.

Nel riquadro di navigazione a sinistra, scegli Asset.

Selezionare Create asset (Crea asset).

In Informazioni sul modello, scegli il modello di asset del tuo dispositivo,SiteWise Tutorial Device Model.

In Informazioni sull'asset, inserisci un nome per il tuo asset. Ad esempio, SiteWise Tutorial Device 1.

Selezionare Create asset (Crea asset).

Per il nuovo asset dispositivo, scegliere Edit (Modifica).

In Misurazioni:

1. In CPU Usage, immettere /tutorial/device/SiteWiseTutorialDevice1/cpu come alias di proprietà. Includi il nome dell' AWS IoT oggetto nell'alias della proprietà, in modo da poter importare dati da tutti i tuoi dispositivi utilizzando un'unica AWS IoT regola.

2. In Memory Usage, immettere /tutorial/device/SiteWiseTutorialDevice1/memory come alias di proprietà.

Selezionare Salva.

Passare alla console AWS IoT SiteWise.

Nel riquadro di navigazione a sinistra, scegli Asset.

Selezionare Create asset (Crea asset).

In Informazioni sul modello, scegli il modello di asset del tuo parco dispositivi,SiteWise Tutorial Device Fleet Model.

In Informazioni sull'asset, inserisci un nome per il tuo asset. Ad esempio, SiteWise Tutorial Device Fleet 1.

Selezionare Create asset (Crea asset).

Per il nuovo asset parco istanze dei dispositivi, scegliere Edit (Modifica).

In Risorse associate a questa risorsa, scegli Aggiungi risorsa associata ed esegui le seguenti operazioni:

1. In Hierarchy (Gerarchia), scegliere Device. Questa gerarchia identifica la relazione di gerarchia tra gli asset parco istanze dei dispositivi e gli asset dispositivi. Questa gerarchia è stata definita nel modello di asset parco istanze dei dispositivi in precedenza in questo tutorial.

2. In Asset, scegliere l'asset dispositivo SiteWise Tutorial Device 1.

(Facoltativo) Se hai creato più risorse del dispositivo in precedenza, ripeti i passaggi da 8 a 10 per ogni risorsa del dispositivo che hai creato.

Selezionare Salva.

A questo punto gli asset dispositivo vengono visualizzati organizzati in gerarchia.

Passare alla console AWS IoT.

Nel riquadro di navigazione a sinistra, scegli Instradamento dei messaggi, quindi scegli Regole.

Scegli Crea regola.

Inserisci un nome e una descrizione per la regola, quindi scegli Avanti.

Inserisci la seguente istruzione SQL e scegli Avanti.

SELECT
  *
FROM
  '$aws/things/+/shadow/update/accepted'
WHERE
  startsWith(topic(3), "SiteWiseTutorialDevice")

Questa istruzione di query di regola funziona perché il servizio shadow del dispositivo pubblica gli aggiornamenti shadow in $aws/things/thingName/shadow/update/accepted. Per ulteriori informazioni sulle ombre dei dispositivi, consulta Device shadow service nella AWS IoT Developer Guide.

Nella clausola WHERE, questa istruzione di query di regola utilizza la funzione topic(3) per ottenere il nome dell'oggetto dal terzo segmento dell'argomento. Quindi, l'istruzione esclude i dispositivi con nomi che non corrispondono a quelli dei dispositivi del tutorial. Per ulteriori informazioni su AWS IoT SQL, consulta i riferimenti AWS IoT SQL nella AWS IoT Developer Guide.

In Rule actions, scegli Invia i dati dei messaggi alle proprietà delle risorse in AWS IoT SiteWise ed esegui le seguenti operazioni:

1. Scegliere By property alias (Per alias di proprietà).

2. In Property alias (Alias proprietà), immettere /tutorial/device/${topic(3)}/cpu.

   La ${...} sintassi è un modello sostitutivo. AWS IoT valuta il contenuto all'interno delle parentesi. Questo modello di sostituzione esegue il pull del nome dell'oggetto dall'argomento per creare un alias univoco per ogni oggetto. Per ulteriori informazioni, consulta Modelli sostitutivi nella Guida per gli sviluppatori. AWS IoT

   Nota

   Poiché un'espressione in un modello di sostituzione viene valutata separatamente dall'istruzione SELECT, non puoi utilizzare un modello di sostituzione per fare riferimento a un alias creato utilizzando una clausola AS. È possibile fare riferimento solo alle informazioni presenti nel payload originale, oltre alle funzioni e agli operatori supportati.

3. In ID di immissione - opzionale , inserisci. ${concat(topic(3), "-cpu-", floor(state.reported.timestamp))}

   Gli ID voce identificano in modo univoco ogni tentativo di immissione del valore. Se una voce restituisce un errore, è possibile trovare l'ID voce nell'output dell'errore per risolvere il problema. Il modello di sostituzione in questo ID voce combina il nome dell'oggetto e il timestamp restituito del dispositivo. Ad esempio, l'ID voce risultante potrebbe essere simile a SiteWiseTutorialDevice1-cpu-1579808494.

4. In Time in seconds (Ora in secondi), immettere ${floor(state.reported.timestamp)}.

   Questo modello di sostituzione calcola l'ora in secondi dal timestamp restituito del dispositivo. In questo tutorial, i dispositivi restituiscono il timestamp in secondi nel formato di ora epoch Unix come numero a virgola mobile.

5. In Offset in nanos - opzionale , inserisci. ${floor((state.reported.timestamp % 1) * 1E9)}

   Questo modello di sostituzione calcola l'offset in nanosecondi dall'ora in secondi convertendo la parte decimale del timestamp restituito del dispositivo.

   Nota

   AWS IoT SiteWise richiede che i tuoi dati abbiano un timestamp corrente in Unix epoch time. Se i dispositivi non restituiscono l'ora in modo accurato, è possibile che l'ora corrente restituita dal motore di regole AWS IoT sia timestamp(). Questa funzione segnala l'ora in millisecondi, quindi è necessario aggiornare i parametri dell'ora dell'azione di regola ai seguenti valori:

   • In Time in seconds (Ora in secondi), immettere ${floor(timestamp() / 1E3)}.

   • In Offset in nanos (Offset in nanosecondi), immettere ${(timestamp() % 1E3) * 1E6}.

6. In Data type (Tipo di dati), scegliere Double (Doppio).

   Questo tipo di dati deve corrispondere al tipo di dati della proprietà dell'asset definita nel modello di asset.

7. In Valore, immetti ${state.reported.cpu}. Nei modelli di sostituzione, è possibile utilizzare l'operatore . per recuperare un valore all'interno di una struttura JSON.

8. Scegliere Add entry (Aggiungi voce) per aggiungere una nuova voce per la proprietà di utilizzo della memoria e completare nuovamente i passaggi seguenti per questa proprietà:

   1. Scegliere By property alias (Per alias di proprietà).

   2. In Property alias (Alias proprietà), immettere /tutorial/device/${topic(3)}/memory.

   3. In Entry ID - opzionale, inserisci. ${concat(topic(3), "-memory-", floor(state.reported.timestamp))}

   4. In Time in seconds (Ora in secondi), immettere ${floor(state.reported.timestamp)}.

   5. In Offset in nanos - opzionale , inserisci. ${floor((state.reported.timestamp % 1) * 1E9)}

   6. In Data type (Tipo di dati), scegliere Double (Doppio).

   7. In Valore, immetti ${state.reported.memory}.

9. In Ruolo IAM, scegli Crea nuovo ruolo per creare un ruolo IAM per questa azione della regola. Questo ruolo consente di AWS IoT inviare i dati alle proprietà dell'asset del parco dispositivi e alla relativa gerarchia degli asset.

10. Inserisci un nome per il ruolo e scegli Crea.

(Facoltativo) Configurare un'azione di errore che è possibile utilizzare per risolvere i problemi della regola. Per ulteriori informazioni, consulta Risolvi i problemi relativi a una regola (AWS IoT SiteWise).

Scegli Avanti.

Rivedi le impostazioni e scegli Crea per creare la regola.

Passare alla console AWS IoT.

Nella parte inferiore del riquadro di spostamento a sinistra scegliere Settings (Impostazioni).

Salvare l'endpoint personalizzato da utilizzare con lo script client del dispositivo. Usare questo endpoint per interagire con le shadow dell'oggetto. Questo endpoint è univoco per l'account nella regione corrente.

L'endpoint personalizzato è simile all'esempio seguente.

identifier.iot.region.amazonaws.com

Aprire una riga di comando ed eseguire il comando seguente per passare alla directory creata in precedenza nel tutorial.

cd iot-sitewise-rule-tutorial

Eseguire il comando seguente per installare SDK per dispositivi AWS IoT per Python.

pip3 install AWSIoTPythonSDK

Per ulteriori informazioni, consulta SDK per dispositivi AWS IoT per Python la Guida per AWS IoT gli sviluppatori

Eseguire il seguente comando per installare psutil, un processo multipiattaforma e una libreria di utilità di sistema.

pip3 install psutil

Per ulteriori informazioni, consultare psutil nell'indice dei pacchetti Python.

Creare un file chiamato thing_performance.py nella directory iot-sitewise-rule-tutorial e quindi copiare il seguente codice Python nel file.

import AWSIoTPythonSDK.MQTTLib as AWSIoTPyMQTT

import json
import psutil
import argparse
import logging
import time


# Configures the argument parser for this program.
def configureParser():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "-e",
        "--endpoint",
        action="store",
        required=True,
        dest="host",
        help="Your AWS IoT custom endpoint",
    )
    parser.add_argument(
        "-r",
        "--rootCA",
        action="store",
        required=True,
        dest="rootCAPath",
        help="Root CA file path",
    )
    parser.add_argument(
        "-c",
        "--cert",
        action="store",
        required=True,
        dest="certificatePath",
        help="Certificate file path",
    )
    parser.add_argument(
        "-k",
        "--key",
        action="store",
        required=True,
        dest="privateKeyPath",
        help="Private key file path",
    )
    parser.add_argument(
        "-p",
        "--port",
        action="store",
        dest="port",
        type=int,
        default=8883,
        help="Port number override",
    )
    parser.add_argument(
        "-n",
        "--thingName",
        action="store",
        required=True,
        dest="thingName",
        help="Targeted thing name",
    )
    parser.add_argument(
        "-d",
        "--requestDelay",
        action="store",
        dest="requestDelay",
        type=float,
        default=1,
        help="Time between requests (in seconds)",
    )
    parser.add_argument(
        "-v",
        "--enableLogging",
        action="store_true",
        dest="enableLogging",
        help="Enable logging for the AWS IoT Device SDK for Python",
    )
    return parser


# An MQTT shadow client that uploads device performance data to AWS IoT at a regular interval.
class PerformanceShadowClient:
    def __init__(
        self,
        thingName,
        host,
        port,
        rootCAPath,
        privateKeyPath,
        certificatePath,
        requestDelay,
    ):
        self.thingName = thingName
        self.host = host
        self.port = port
        self.rootCAPath = rootCAPath
        self.privateKeyPath = privateKeyPath
        self.certificatePath = certificatePath
        self.requestDelay = requestDelay

    # Updates this thing's shadow with system performance data at a regular interval.
    def run(self):
        print("Connecting MQTT client for {}...".format(self.thingName))
        mqttClient = self.configureMQTTClient()
        mqttClient.connect()
        print("MQTT client for {} connected".format(self.thingName))
        deviceShadowHandler = mqttClient.createShadowHandlerWithName(
            self.thingName, True
        )

        print("Running performance shadow client for {}...\n".format(self.thingName))
        while True:
            performance = self.readPerformance()
            print("[{}]".format(self.thingName))
            print("CPU:\t{}%".format(performance["cpu"]))
            print("Memory:\t{}%\n".format(performance["memory"]))
            payload = {"state": {"reported": performance}}
            deviceShadowHandler.shadowUpdate(
                json.dumps(payload), self.shadowUpdateCallback, 5
            )
            time.sleep(args.requestDelay)

    # Configures the MQTT shadow client for this thing.
    def configureMQTTClient(self):
        mqttClient = AWSIoTPyMQTT.AWSIoTMQTTShadowClient(self.thingName)
        mqttClient.configureEndpoint(self.host, self.port)
        mqttClient.configureCredentials(
            self.rootCAPath, self.privateKeyPath, self.certificatePath
        )
        mqttClient.configureAutoReconnectBackoffTime(1, 32, 20)
        mqttClient.configureConnectDisconnectTimeout(10)
        mqttClient.configureMQTTOperationTimeout(5)
        return mqttClient

    # Returns the local device's CPU usage, memory usage, and timestamp.
    def readPerformance(self):
        cpu = psutil.cpu_percent()
        memory = psutil.virtual_memory().percent
        timestamp = time.time()
        return {"cpu": cpu, "memory": memory, "timestamp": timestamp}

    # Prints the result of a shadow update call.
    def shadowUpdateCallback(self, payload, responseStatus, token):
        print("[{}]".format(self.thingName))
        print("Update request {} {}\n".format(token, responseStatus))


# Configures debug logging for the AWS IoT Device SDK for Python.
def configureLogging():
    logger = logging.getLogger("AWSIoTPythonSDK.core")
    logger.setLevel(logging.DEBUG)
    streamHandler = logging.StreamHandler()
    formatter = logging.Formatter(
        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
    )
    streamHandler.setFormatter(formatter)
    logger.addHandler(streamHandler)


# Runs the performance shadow client with user arguments.
if __name__ == "__main__":
    parser = configureParser()
    args = parser.parse_args()
    if args.enableLogging:
        configureLogging()
    thingClient = PerformanceShadowClient(
        args.thingName,
        args.host,
        args.port,
        args.rootCAPath,
        args.privateKeyPath,
        args.certificatePath,
        args.requestDelay,
    )
    thingClient.run()

Esegui thing_performance.py dalla riga di comando con i parametri seguenti:

Il comando è simile al seguente esempio:

python3 thing_performance.py \
  --thingName SiteWiseTutorialDevice1 \
  --endpoint identifier.iot.region.amazonaws.com \
  --rootCA AmazonRootCA1.pem \
  --cert device1/thing-id-certificate.pem.crt \
  --key device1/thing-id-private.pem.key

Se stai eseguendo lo script per altre AWS IoT cose, aggiorna di conseguenza il nome dell'oggetto e la directory dei certificati.

Provare ad aprire e chiudere i programmi sul dispositivo per vedere come cambiano gli utilizzi della CPU e della memoria. Lo script stampa ogni lettura dell'utilizzo della CPU e della memoria. Se lo script carica i dati nel servizio shadow del dispositivo correttamente, l'output dello script è simile all'esempio seguente.

[SiteWiseTutorialDevice1]
CPU:    24.6%
Memory: 85.2%

[SiteWiseTutorialDevice1]
Update request e6686e44-fca0-44db-aa48-3ca81726f3e3 accepted

Attenersi alla seguente procedura per verificare che lo script aggiorni la shadow del dispositivo:

1. Passare alla console AWS IoT.

2. Nel riquadro di navigazione a sinistra, scegli Tutti i dispositivi, quindi scegli Cose.

3. Scegli la tua cosa, SiteWiseTutorialDevice.

4. Scegliete la scheda Device Shadows, scegliete Classic Shadows e verificate che lo stato Shadow sia simile all'esempio seguente.

   {
     "reported": {
       "cpu": 24.6,
       "memory": 85.2,
       "timestamp": 1579567542.2835066
     }
   }

   Se lo stato ombra del tuo oggetto è vuoto o non assomiglia all'esempio precedente, controlla che lo script sia in esecuzione e connesso AWS IoT correttamente. Se lo script continua a scadere durante la connessione a AWS IoT, controlla che la tua policy sugli oggetti sia configurata in base a questo tutorial.

Attenersi alla seguente procedura per verificare che l'azione di regola invii dati ad AWS IoT SiteWise:

1. Passare alla console AWS IoT SiteWise.

2. Nel riquadro di navigazione a sinistra, scegli Asset.

3. Scegli la freccia accanto all'asset del tuo parco dispositivi (SiteWise Tutorial Device Fleet 1) per espandere la gerarchia degli asset, quindi scegli l'asset del tuo dispositivo (SiteWise Tutorial Device1).

4. Scegliere Measurements (Misurazioni).

5. Verificare che le celle Latest value (Valore più recente) abbiano i valori per le proprietà CPU Usage e Memory Usage.

   

6. Se le proprietà CPU Usage e Memory Usage non hanno i valori più recenti, aggiornare la pagina. Se i valori non vengono visualizzati dopo pochi minuti, consultare Risolvi i problemi relativi a una regola (AWS IoT SiteWise).

Accedi alla console AWS IoT SiteWise

Nel riquadro di navigazione a sinistra, scegli Asset.

Quando elimini le risorse in AWS IoT SiteWise, devi prima dissociarle.

Completare la procedura seguente per dissociare gli asset del dispositivo dall'asset parco istanze dei dispositivi:

1. Scegli la risorsa del tuo parco dispositivi (SiteWise Tutorial Device Fleet 1).

2. Scegli Modifica.

3. In Assets associated to this asset (Asset associati a questo asset), scegliere Disassociate (Dissocia) per ogni asset dispositivo associato a questo asset parco istanze dei dispositivi.

4. Selezionare Salva.

   A questo punto gli asset dispositivo non sono più organizzati in gerarchia.

Scegliere l'asset dispositivo (SiteWise Tutorial Device 1).

Scegliere Elimina.

Nella finestra di dialogo di conferma immettere Delete e quindi scegliere Delete (Elimina).

Ripeti i passaggi da 4 a 6 per ogni risorsa del dispositivo e per la risorsa del parco dispositivi (SiteWise Tutorial Device Fleet 1).

Passare alla console AWS IoT SiteWise.

Se non è già stato fatto, eliminare gli asset del dispositivo e del parco istanze dei dispositivi. Per ulteriori informazioni, consultare la procedura precedente. Non è possibile eliminare un modello se sono presenti asset creati da quel modello.

Nel riquadro di navigazione a sinistra scegliere Models (Modelli).

Scegliere l'asset parco istanze dei dispositivi (SiteWise Tutorial Device Fleet Model).

Quando si eliminano i modelli di asset gerarchici, iniziate eliminando prima il modello di asset principale.

Scegliere Elimina.

Nella finestra di dialogo di conferma immettere Delete e quindi scegliere Delete (Elimina).

Ripetere i passaggi da 4 a 6 per il modello di asset del dispositivo (SiteWise Tutorial Device Model).

Passare alla console AWS IoT.

Nel riquadro di navigazione a sinistra, scegli Instradamento dei messaggi, quindi scegli Regole.

Seleziona la tua regola e scegli Elimina.

Nella finestra di dialogo di conferma, inserisci il nome della regola e scegli Elimina.