Tutorial: Connessione di un dispositivo AWS IoT Core tramite il AWS IoT dispositivo SDK

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Questo tutorial mostra come connettere un dispositivo a AWS IoT Core cui inviare e ricevere dati da AWS IoT e verso. Dopo aver completato questo tutorial, il dispositivo sarà configurato per la connessione AWS IoT Core e capirai come comunicano i AWS IoT dispositivi.

Prerequisiti

Prima di iniziare il tutorial, assicurati di disporre:

Prepara il tuo dispositivo per AWS IoT

In Guida introduttiva ai AWS IoT Core tutorial, hai preparato il tuo dispositivo e account AWS in modo che potessero comunicare. Questa sezione esamina gli aspetti di tale preparazione che si applicano alla connessione di qualsiasi dispositivo con AWS IoT Core.

Affinché un dispositivo si connetta a AWS IoT Core:

Rivedi il protocollo MQTT

Prima di parlare dell'app di esempio, è utile comprendere il MQTT protocollo. Il MQTT protocollo offre alcuni vantaggi rispetto ad altri protocolli di comunicazione di rete, ad esempioHTTP, il che lo rende una scelta popolare per i dispositivi IoT. Questa sezione esamina gli aspetti MQTT chiave relativi a questo tutorial. Per informazioni sulla MQTT comparazione conHTTP, vediScelta di un protocollo applicativo per la comunicazione del dispositivo.

MQTTutilizza un modello di comunicazione pubblica/sottoscrizione

Il MQTT protocollo utilizza un publish/subscribe communication model with its host. This model differs from the request/response modello che utilizza. HTTP ConMQTT, i dispositivi stabiliscono una sessione con l'host identificata da un ID client univoco. Per inviare dati, i dispositivi pubblicano i messaggi identificati da argomenti al broker messaggi nell'host. Per ricevere messaggi dal broker di messaggi, i dispositivi sottoscrivono agli argomenti inviando al broker messaggi i filtri argomento nelle richieste di sottoscrizione al broker di messaggi.

MQTTsupporta sessioni persistenti

Il broker di messaggi riceve i messaggi dai dispositivi e pubblica i messaggi ai dispositivi che hanno effettuato una sottoscrizione. Con le sessioni persistenti che rimangono attive anche quando il dispositivo di avvio è disconnesso, i dispositivi possono recuperare i messaggi pubblicati mentre erano disconnessi. Sul lato dispositivo, MQTT supporta i livelli di qualità del servizio (QoS) che garantiscono che l'host riceva i messaggi inviati dal dispositivo.

Consulta l'app di SDK esempio per dispositivi pubsub.py

Questa sezione esamina l'app di pubsub.py esempio di AWS IoT Device SDK v2 for Python utilizzata in questo tutorial. Qui esamineremo come si collega per AWS IoT Core pubblicare e sottoscrivere MQTT i messaggi. La sezione successiva presenta alcuni esercizi per aiutarti a scoprire in che modo un dispositivo si connette e comunica. AWS IoT Core

Protocolli di comunicazione

L'pubsub.pyesempio mostra una MQTT connessione che utilizza i protocolli MQTT and MQTT overWSS. La libreria AWS common runtime (AWS CRT) fornisce il supporto del protocollo di comunicazione di basso livello ed è inclusa nel AWS IoT Device SDK v2 for Python.

MQTT

Le chiamate pubsub.py di esempio mtls_from_path (mostrate qui) sono quelle con mqtt_connection_buildercui stabilire una connessione AWS IoT Core utilizzando il protocollo. MQTT mtls_from_pathutilizza i certificati X.509 e la TLS versione 1.2 per autenticare il dispositivo. La AWS CRT libreria gestisce i dettagli di livello inferiore di tale connessione.

mqtt_connection = mqtt_connection_builder.mtls_from_path(
    endpoint=args.endpoint,
    cert_filepath=args.cert,
    pri_key_filepath=args.key,
    ca_filepath=args.ca_file,
    client_bootstrap=client_bootstrap,
    on_connection_interrupted=on_connection_interrupted,
    on_connection_resumed=on_connection_resumed,
    client_id=args.client_id,
    clean_session=False,
    keep_alive_secs=6
)

MQTTfinito WSS

Le chiamate di pubsub.py esempio websockets_with_default_aws_signing (mostrate qui) in mqtt_connection_buildercui stabilire una connessione AWS IoT Core utilizzando il MQTT protocollo overWSS. websockets_with_default_aws_signingcrea una MQTT connessione WSS utilizzando Signature V4 per autenticare il dispositivo.

mqtt_connection = mqtt_connection_builder.websockets_with_default_aws_signing(
    endpoint=args.endpoint,
    client_bootstrap=client_bootstrap,
    region=args.signing_region,
    credentials_provider=credentials_provider,
    websocket_proxy_options=proxy_options,
    ca_filepath=args.ca_file,
    on_connection_interrupted=on_connection_interrupted,
    on_connection_resumed=on_connection_resumed,
    client_id=args.client_id,
    clean_session=False,
    keep_alive_secs=6
)

HTTPS

Che direHTTPS? AWS IoT Core supporta dispositivi che pubblicano HTTPS richieste. Dal punto di vista della programmazione, i dispositivi inviano HTTPS le richieste AWS IoT Core come qualsiasi altra applicazione. Per un esempio di programma Python che invia un HTTP messaggio da un dispositivo, vedi l'esempio di HTTPS codice che utilizza la libreria di Python. requests Questo esempio invia un messaggio a AWS IoT Core using HTTPS such che lo AWS IoT Core interpreta come messaggio. MQTT

Sebbene AWS IoT Core supporti HTTPS le richieste provenienti dai dispositivi, assicuratevi di esaminare le informazioni Scelta di un protocollo applicativo per la comunicazione del dispositivo in merito in modo da poter prendere una decisione informata sul protocollo da utilizzare per le comunicazioni tra i dispositivi.

Sessioni persistenti

Nell'app di esempio, l’impostazione del parametro clean_session di False indica che la connessione deve essere persistente. In pratica, ciò significa che la connessione aperta da questa chiamata si riconnette a una sessione persistente esistente, se esiste. In caso contrario, crea e si connette a una nuova sessione persistente.

Con una sessione persistente, i messaggi inviati al dispositivo vengono archiviati dal broker di messaggi mentre il dispositivo non è connesso. Quando un dispositivo si riconnette a una sessione persistente, il broker di messaggi invia al dispositivo tutti i messaggi archiviati a cui è stato sottoscritto.

Senza una sessione persistente, il dispositivo non riceverà messaggi inviati mentre il dispositivo non è connesso. L'opzione da utilizzare dipende dall'applicazione e se i messaggi che si verificano mentre un dispositivo non è connesso devono essere comunicati. Per ulteriori informazioni, consulta Sessioni persistenti MQTT.

Qualità del servizio

Quando il dispositivo pubblica e sottoscrive messaggi, è possibile impostare la qualità del servizio (QoS) preferita. AWS IoT supporta i livelli QoS 0 e 1 per le operazioni di pubblicazione e sottoscrizione. Per ulteriori informazioni sui livelli QoS in AWS IoT, vedere. Opzioni di qualità del servizio MQTT (QoS)

Il AWS CRT runtime per Python definisce queste costanti per i livelli QoS che supporta:

Nell'app di esempio, le richieste di pubblicazione e sottoscrizione vengono effettuate con un livello QoS di 1 (mqtt.QoS.AT_LEAST_ONCE).

Pubblicazione di messaggi

Dopo aver stabilito con successo una connessione a AWS IoT Core, i dispositivi possono pubblicare messaggi. L’esempio pubsub.py fa ciò chiamando l'operazione publish dell'oggetto mqtt_connection.

mqtt_connection.publish(
    topic=args.topic,
    payload=message,
    qos=mqtt.QoS.AT_LEAST_ONCE
)

Abbonamento messaggi

Per ricevere messaggi da AWS IoT e altri servizi e dispositivi, i dispositivi si iscrivono a tali messaggi in base al nome dell'argomento. I dispositivi possono sottoscrivere singoli messaggi specificando un nome argomento e a un gruppo di messaggi specificando un filtro di argomenti che può includere caratteri jolly. L’esempio pubsub.py utilizza il codice mostrato qui per iscriversi ai messaggi e registrare le funzioni di callback per elaborare il messaggio dopo che è stato ricevuto.

subscribe_future, packet_id = mqtt_connection.subscribe(
    topic=args.topic,
    qos=mqtt.QoS.AT_LEAST_ONCE,
    callback=on_message_received
)
subscribe_result = subscribe_future.result()

La funzione mqtt_connection.subscribe restituisce un futuro e un ID pacchetto. Se la richiesta di sottoscrizione è stata avviata correttamente, l'ID del pacchetto restituito è maggiore di 0. Per assicurarsi che la sottoscrizione sia stata ricevuta e registrata dal broker di messaggi, è necessario attendere la restituzione del risultato dell'operazione asincrona, come illustrato nell'esempio del codice.

La funzione di callback

Il callback nei processi di esempio pubsub.py elabora i messaggi sottoscritti quando il dispositivo li riceve.

def on_message_received(topic, payload, **kwargs):
    print("Received message from topic '{}': {}".format(topic, payload))
    global received_count
    received_count += 1
    if received_count == args.count:
        received_all_event.set()

Nell’esempio pubsub.py, on_message_received visualizza solo l'argomento e il relativo payload. Conta inoltre i messaggi ricevuti per terminare il programma dopo il raggiungimento del limite.

La tua app valuterà l'argomento e il payload per determinare quali operazioni eseguire.

Disconnessione e riconnessione del dispositivo

L’esempio pubsub.py include funzioni di callback che vengono chiamate quando il dispositivo viene disconnesso e quando la connessione viene ristabilita. Le operazioni intraprese dal dispositivo su questi eventi sono specifiche dell'applicazione.

Quando un dispositivo si connette per la prima volta, deve sottoscrivere gli argomenti da ricevere. Se la sessione di un dispositivo è presente durante la riconnessione, le relative sottoscrizioni vengono ripristinate e tutti i messaggi memorizzati da tali sottoscrizioni vengono inviati al dispositivo dopo la riconnessione.

Se la sessione di un dispositivo non esiste più quando si riconnette, è necessario sottoscrivere nuovamente alle sottoscrizioni. Le sessioni persistenti hanno una durata limitata e possono scadere quando il dispositivo viene disconnesso per troppo tempo.

Connect il dispositivo e comunica con AWS IoT Core

Questa sezione presenta alcuni esercizi che consentono di esplorare diversi aspetti della connessione del dispositivo a AWS IoT Core. Per questi esercizi, utilizzerai il client di MQTT test nella AWS IoT console per vedere cosa pubblica il tuo dispositivo e per pubblicare messaggi sul tuo dispositivo. Questi esercizi utilizzano l'pubsub.pyesempio di AWS IoT Device SDK v2 for Python e si basano sulla tua esperienza Guida introduttiva ai AWS IoT Core tutorial con i tutorial.

Per questi esercizi, inizierai dal programma di esempio pubsub.py.

Iscriviti ai filtri per argomenti jolly

In questo esercizio, modificherai la riga di comando utilizzata per chiamare pubsub.py per sottoscrivere un filtro dell’argomento con caratteri jolly ed elaborare i messaggi ricevuti in base all'argomento del messaggio.

Procedura dell’esercizio

Per questo esercizio, immagina che il dispositivo contenga un controllo della temperatura e un controllo della luce. Utilizza questi nomi di argomenti per identificare i messaggi che li riguardano.

Risultato dell'esercizio

Con questo pubsub.py sottoscritto ai messaggi utilizzando un filtro argomento jolly, li ha ricevuti e visualizzati nella finestra del terminale. Si noti come si è sottoscritto a un singolo filtro dell’argomento e la funzione di callback è stata chiamata per elaborare i messaggi con due argomenti distinti.

Processo sottoscrizioni filtro dell’argomento

Basandosi sull'esercizio precedente, modifica l’app di esempio pubsub.py per valutare gli argomenti dei messaggi ed elaborare i messaggi sottoscritti in base all'argomento.

Procedura dell’esercizio

Dovrebbe essere visualizzato un elemento simile a quello nella finestra del terminale.

Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-af794be0-7542-45a0-b0af-0b0ea7474517'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...
Received message from topic 'device/light/details': b'{ "desiredLight": 100, "currentLight": 50 }'
Received light request: b'{ "desiredLight": 100, "currentLight": 50 }'
Received message from topic 'device/temp/details': b'{ "desiredTemp": 20, "currentTemp": 15 }'
Received temperature request: b'{ "desiredTemp": 20, "currentTemp": 15 }'
2 message(s) received.
Disconnecting...
Disconnected!

Risultato dell'esercizio

In questo esercizio è stato aggiunto il codice in modo che l'app di esempio riconosca ed elabori più messaggi nella funzione di callback. Con questo, il tuo dispositivo potrebbe ricevere messaggi e agire su di essi.

Un altro modo per consentire al tuo dispositivo di ricevere e processare diversi messaggi separatamente e assegnare ogni abbonamento alla propria funzione di callback.

Pubblica messaggi dal tuo dispositivo

È possibile utilizzare l'app di esempio pubsub.py per pubblicare messaggi dal dispositivo. Anche se pubblicherà i messaggi così come sono, i messaggi non possono essere letti come JSON documenti. Questo esercizio modifica l'app di esempio per poter pubblicare JSON documenti leggibili nel payload dei messaggi. AWS IoT Core

Procedura dell’esercizio

In questo esercizio, il seguente messaggio verrà inviato con l’argomento device/data.

{
    "timestamp": 1601048303,
    "sensorId": 28,
    "sensorData": [
        {
        "sensorName": "Wind speed",
        "sensorValue": 34.2211224
        }
    ]
}

Per impostazione predefinita, pubsub3.py effettua la sottoscrizione anche ai messaggi che invia. Dovresti vedere che ha ricevuto i messaggi nell'output dell'app. La finestra del terminale dovrebbe essere simile a questa.

Connecting to a3qEXAMPLEsffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-5cff18ae-1e92-4c38-a9d4-7b9771afc52f'...
Connected!
Subscribing to topic 'device/data'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 2 message(s)
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
2 message(s) received.
Disconnecting...
Disconnected!

Risultato dell’esercizio

In questo modo, il dispositivo può generare messaggi da inviare per AWS IoT Core testare la connettività di base e fornire messaggi AWS IoT Core da elaborare. Ad esempio, puoi utilizzare questa app per inviare dati di test dal tuo dispositivo per testare le azioni delle AWS IoT regole.

Rivedi i risultati

Gli esempi di questo tutorial ti hanno fornito un'esperienza pratica sulle nozioni di base con cui i dispositivi possono comunicare, AWS IoT Core una parte fondamentale della tua soluzione. AWS IoT Quando i dispositivi sono in grado di comunicare AWS IoT Core, possono trasmettere messaggi ai AWS servizi e ad altri dispositivi su cui possono agire. Allo stesso modo, AWS i servizi e gli altri dispositivi possono elaborare informazioni che generano l'invio di messaggi ai dispositivi dell'utente.

Quando sei pronto per AWS IoT Core approfondire, prova questi tutorial: