Tutorial: Connessione di un dispositivo AWS IoT Core tramite AWS IoT Device SDK - AWS IoT Core
PrerequisitiPrepara il tuo dispositivo per AWS IoTEsamina il protocollo MQTTRevisione dell'app di esempio pubsub.py SDK per dispositiviConnect il dispositivo e comunica con AWS IoT CoreRivedi i risultati

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à.

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

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

Argomenti

Prerequisiti

Prima di iniziare il tutorial, assicurati di disporre:

  • Aver completato Guida introduttiva ai AWS IoT Core tutorial

    Nella sezione di quel tutorial in cui è necessario Configurazione del dispositivo, seleziona l’opzione Connettere un Raspberry Pi o altro dispositivo per il tuo dispositivo e usa le opzioni del linguaggio Python per configurare il tuo dispositivo.

    Nota

    Assicurati di tenere aperta la finestra terminale che usi in quel tutorial perché la userai anche in questo.

  • Un dispositivo in grado di eseguire AWS IoT Device SDK v2 per Python.

    Questo tutorial mostra come connettere un dispositivo AWS IoT Core utilizzando esempi di codice Python, che richiedono un dispositivo relativamente potente. Se lavori con dispositivi con vincoli di risorse, questi esempi di codice potrebbero non funzionare su di essi. In tal caso, potresti avere più successo con il Tutorial: Utilizzo del SDK per dispositivi AWS IoT per Embedded C tutorial.

  • Hai ottenuto le informazioni richieste per la connessione al dispositivo

    Per connettere il dispositivo a AWS IoT, è necessario disporre di informazioni sul nome dell'oggetto, sul nome host e sul numero di porta.

    Nota

    Puoi anche utilizzare l'autenticazione personalizzata a cui connettere i dispositivi AWS IoT Core. I dati di connessione trasmessi alla funzione Lambda dell'autorizzatore dipendono dal protocollo utilizzato.

    • Nome dell'oggetto: il nome dell' AWS IoT oggetto a cui vuoi connetterti. Devi prima esserti registrato come AWS IoT dispositivo. Per ulteriori informazioni, consulta Gestione dei dispositivi con AWS IoT.

    • Nome host: il nome host per l'endpoint IoT specifico dell'account.

    • Numero di porta: il numero di porta a cui connettersi.

    Puoi usare il configureEndpoint metodo in AWS IoT Python SDK per configurare il nome host e il numero di porta.

    myAWSIoTMQTTClient.configureEndpoint("random.iot.region.amazonaws.com", 8883)

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:

  1. È necessario disporre di un Account AWS.

    La procedura riportata di seguito Configurare Account AWS descrive come crearne uno Account AWS se non ne hai già uno.

  2. In quell'account, devi avere le seguenti AWS IoT risorse definite per il dispositivo nella tua Account AWS regione.

    La procedura in Crea AWS IoT risorse descrive come creare queste risorse per il dispositivo nell’account Account AWS e regione.

    • Un certificato del dispositivo registrato con AWS IoT e attivato per autenticare il dispositivo.

      Il certificato viene spesso creato con un oggetto AWS IoT e collegato a esso. Sebbene un oggetto non sia necessario per la connessione di un dispositivo AWS IoT, rende disponibili AWS IoT funzionalità aggiuntive per il dispositivo.

    • Una politica allegata al certificato del dispositivo che lo autorizza a connettersi AWS IoT Core e a eseguire tutte le azioni desiderate.

  3. Una connessione a Internet che può accedere all’account Account AWS degli endpoint del dispositivo.

    Gli endpoint del dispositivo sono descritti AWS IoT dati del dispositivo e endpoint di servizio e possono essere visualizzati nella pagina delle impostazioni della AWS IoT console.

  4. Software di comunicazione SDKs fornito dal AWS IoT dispositivo. Questo tutorial utilizza AWS IoT Device SDK v2 per Python.

Esamina il protocollo MQTT

Prima di parlare dell'app di esempio, questo ti aiuta a capire il protocollo MQTT. Il protocollo MQTT offre alcuni vantaggi rispetto ad altri protocolli di comunicazione di rete, come HTTP, così da essere una scelta popolare per i dispositivi IoT. Questa sezione esamina gli aspetti chiave di MQTT applicabili a questo tutorial. Per informazioni sul confronto tra MQTT e HTTP, consulta Scelta di un protocollo applicativo per la comunicazione del dispositivo.

MQTT utilizza un modello di publish/subscribe comunicazione

Il protocollo MQTT utilizza un modello di publish/subscribe comunicazione con il suo host. Questo modello è diverso dal request/response modello utilizzato da HTTP. Con MQTT, 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.

MQTT supporta 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 assicurano che l'host riceva i messaggi inviati dal dispositivo.

Revisione dell'app di esempio pubsub.py SDK per dispositivi

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

Protocolli di comunicazione

L’esempio pubsub.py illustra una connessione MQTT utilizzando i protocolli MQTT e MQTT su WSS. La libreria AWS Common Runtime (AWS CRT) fornisce il supporto del protocollo di comunicazione di basso livello ed è inclusa in AWS IoT Device SDK v2 for Python.

MQTT

Le chiamate pubsub.py di esempio mtls_from_path (mostrate qui) in cui mqtt_connection_builderstabilire una connessione utilizzando il protocollo MQTT AWS IoT Core . mtls_from_pathutilizza certificati X.509 e TLS v1.2 per autenticare il dispositivo. La libreria AWS CRT 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
)
endpoint

L'endpoint Account AWS del tuo dispositivo IoT

Nell'app di esempio, il valore viene passato dalla riga di comando.

cert_filepath

Il percorso del certificato del file del dispositivo

Nell'app di esempio, il valore viene passato dalla riga di comando.

pri_key_filepath

Il percorso al file della chiave privata del dispositivo creata con il relativo file di certificato

Nell'app di esempio, il valore viene passato dalla riga di comando.

ca_filepath

Il percorso del file Root CA. Obbligatorio solo se il server MQTT utilizza un certificato che non è già presente nell'archivio.

Nell'app di esempio, il valore viene passato dalla riga di comando.

client_bootstrap

L'oggetto runtime comune che gestisce le attività di comunicazione socket

Nell'app di esempio, questo oggetto viene istanziato appena prima della chiamata a mqtt_connection_builder.mtls_from_path.

on_connection_interrupted
on_connection_resumed

Le funzioni di richiamata da richiamare quando la connessione del dispositivo viene interrotta e ripresa

client_id

L'ID che identifica il dispositivo in modo univoco nella Regione AWS

Nell'app di esempio, il valore viene passato dalla riga di comando.

clean_session

Se avviare una nuova sessione persistente o, se presente, riconnettersi a una esistente

keep_alive_secs

Il valore keep alive, in secondi, per inviare la richiesta CONNECT. Un ping verrà inviato automaticamente a questo intervallo. Se il server non riceve un ping dopo 1,5 volte questo valore, presuppone che la connessione sia stata persa.

MQTT su WSS

L'esempio pubsub.py chiama websockets_with_default_aws_signing (mostrato qui) in mqtt_connection_builder per stabilire una connessione con AWS IoT Core utilizzando il protocollo MQTT su WSS. websockets_with_default_aws_signing crea una connessione MQTT su WSS usando Firma 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
)
endpoint

L'endpoint Account AWS del tuo dispositivo IoT

Nell'app di esempio, il valore viene passato dalla riga di comando.

client_bootstrap

L'oggetto runtime comune che gestisce le attività di comunicazione socket

Nell'app di esempio, questo oggetto viene istanziato appena prima della chiamata a mqtt_connection_builder.websockets_with_default_aws_signing.

region

La regione di AWS firma utilizzata dall'autenticazione Signature V4. Nello stato pubsub.py, passa il parametro inserito nella riga di comando.

Nell'app di esempio, il valore viene passato dalla riga di comando.

credentials_provider

Le AWS credenziali fornite da utilizzare per l'autenticazione

Nell'app di esempio, questo oggetto viene istanziato appena prima della chiamata a mqtt_connection_builder.websockets_with_default_aws_signing.

websocket_proxy_options

Opzioni proxy HTTP, se si utilizza un host proxy

Nell'app di esempio, questo valore viene inizializzato appena prima della chiamata a mqtt_connection_builder.websockets_with_default_aws_signing.

ca_filepath

Il percorso del file Root CA. Obbligatorio solo se il server MQTT utilizza un certificato che non è già presente nell'archivio.

Nell'app di esempio, il valore viene passato dalla riga di comando.

on_connection_interrupted
on_connection_resumed

Le funzioni di richiamata da richiamare quando la connessione del dispositivo viene interrotta e ripresa

client_id

L'ID che identifichi il dispositivo in modo univoco nella Regione AWS.

Nell'app di esempio, il valore viene passato dalla riga di comando.

clean_session

Se avviare una nuova sessione persistente o, se presente, riconnettersi a una esistente

keep_alive_secs

Il valore keep alive, in secondi, per inviare la richiesta CONNECT. Un ping verrà inviato automaticamente a questo intervallo. Se il server non riceve un ping dopo 1,5 volte questo valore, presuppone che la connessione venga persa.

HTTPS

Che dire di HTTPS? AWS IoT Core supporta dispositivi che pubblicano richieste HTTPS. Dal punto di vista della programmazione, i dispositivi inviano richieste HTTPS a AWS IoT Core come qualsiasi altra applicazione. Per un esempio di un programma Python che invia un messaggio HTTP da un dispositivo, consulta l’esempio di codice HTTPS utilizzando la libreria di Python requests. Questo esempio invia un messaggio all' AWS IoT Core utilizzo di HTTPS in modo che lo AWS IoT Core interpreti come un messaggio MQTT.

Sebbene AWS IoT Core supporti le richieste HTTPS 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 runtime AWS CRT per Python definisce queste costanti per i livelli QoS che supporta:

Livelli della qualità del servizio di Python
Livello QoS MQTT Valore simbolico Python utilizzato da SDK Descrizione
QoS livello 0 mqtt.QoS.AT_MOST_ONCE Verrà effettuato un solo tentativo di inviare il messaggio, che sia ricevuto o meno. Il messaggio potrebbe non venire inviato, ad esempio se il dispositivo non è connesso o si verifica un errore di rete.
QoS livello 1 mqtt.QoS.AT_LEAST_ONCE Il messaggio viene inviato ripetutamente finché non si riceve un riconoscimento PUBACK.

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

  • QoS in fase di pubblicazione

    Quando un dispositivo pubblica un messaggio con QoS livello 1, invia il messaggio ripetutamente fino a quando non riceve una risposta PUBACK dal broker di messaggi. Se il dispositivo non è connesso, il messaggio viene messo in coda per essere inviato dopo la riconnessione.

  • QoS in abbonamento

    Quando un dispositivo sottoscrive un messaggio con QoS livello 1, il broker di messaggi salva i messaggi a cui il dispositivo è sottoscritto fino a quando non possono essere inviati al dispositivo. Il broker di messaggi restituisce i messaggi fino a quando non riceve una risposta PUBACK dal dispositivo.

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
)
topic

Nome dell'argomento del messaggio che identifica il messaggio

Nell'app di esempio, ciò viene passato dalla riga di comando.

payload

Il payload del messaggio formattato come stringa (ad esempio, un documento JSON)

Nell'app di esempio, ciò viene passato dalla riga di comando.

Un documento JSON è un formato di payload comune e riconosciuto da altri AWS IoT servizi; tuttavia, il formato dei dati del payload del messaggio può essere qualsiasi cosa concordata tra editori e abbonati. Ttuttavia, altri servizi AWS IoT , riconoscono solo JSON e CBOR in alcuni casi per la maggior parte delle operazioni.

qos

Il livello QoS per questo messaggio

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()
topic

L'argomento a cui effettuare la sottoscrizione. Può trattarsi di un nome di argomento o di un filtro dell’argomento.

Nell'app di esempio, ciò viene passato dalla riga di comando.

qos

Se il broker di messaggi deve archiviare questi messaggi mentre il dispositivo è disconnesso.

Valore di mqtt.QoS.AT_LEAST_ONCE (QoS livello 1), richiede una sessione persistente da specificare (clean_session=False) quando viene creata la connessione.

callback

La funzione da chiamare per elaborare il messaggio sottoscritto.

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()
topic

L'argomento del messaggio

Questo è il nome dell'argomento specifico del messaggio ricevuto, anche se è stato sottoscritto un filtro dell’argomento.

payload

Payload del messaggio

Il formato è specifico per l'applicazione.

kwargs

Possibili argomenti aggiuntivi come descritto in mqtt.Connection.subscribe.

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 test MQTT nella console AWS IoT per vedere cosa pubblica il dispositivo e pubblicare messaggi sul dispositivo. Questi esercizi utilizzano il pubsub.py di esempio dall'SDK del dispositivo AWS IoT v2 per Python e si basano sulla tua esperienza con i tutorial Guida introduttiva ai AWS IoT Core tutorial.

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

Nota

Questi esercizi presuppongono che tu abbia completato i tutorial Guida introduttiva ai AWS IoT Core tutorial e abbia utilizzato la finestra del terminale per il dispositivo da quel tutorial.

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.

  1. Prima di iniziare l'esercizio, prova a eseguire questo comando dai tutorial Guida introduttiva ai AWS IoT Core tutorial sul tuo dispositivo per assicurarti che tutto sia pronto per l'esercizio.

    cd ~/aws-iot-device-sdk-python-v2/samples
python3 pubsub.py --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint

    Dovresti vedere lo stesso output che hai visto nel Tutorial sulle nozioni di base.

  2. Per questo esercizio, modifica questi parametri della riga di comando.

    Azione

    Parametri della riga di comando

    Effetto

    aggiungi

    --message ""

    Configura pubsub.py solo per l’ascolto

    aggiungi

    --count 2

    Termina il programma dopo aver ricevuto due messaggi

    modifica

    --topic device/+/details

    Definisci il filtro degli argomenti a cui sottoscrivere

    L'esecuzione di queste modifiche alla riga di comando iniziale si traduce in questa riga di comando. Inserisci questo comando nella finestra del terminale per il tuo dispositivo.

    python3 pubsub.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint

    Il programma dovrebbe mostrare qualcosa del genere:

    Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-24d7cdcc-cc01-458c-8488-2d05849691e1'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...

    Se vedi qualcosa di simile sul tuo terminale, il tuo dispositivo è pronto e ascolta i messaggi in cui i nomi degli argomenti iniziano con device e terminano con /detail. Quindi, è il momento di provare.

  3. Di seguito sono riportati un paio di messaggi che il dispositivo potrebbe ricevere.

    Nome argomento

    Payload del messaggio

    device/temp/details

    { "desiredTemp": 20, "currentTemp": 15 }

    device/light/details

    { "desiredLight": 100, "currentLight": 50 }

  4. Utilizzando il client di test MQTT nella AWS IoT console, inviate i messaggi descritti nel passaggio precedente al dispositivo.

    1. Apri il client di test MQTT nella AWS IoT console.

    2. In Subscribe to a topic (Sottoscrivi un argomento) nel campo Subscription topic field (Argomento sottoscrizione), inserisci il filtro dell’argomento: device/+/details, quindi scegli Subscribe to topic (Sottoscrivi nell’argomento).

    3. Nella colonna Subscriptions (Sottoscrizioni) del client di test MQTT, seleziona device/+/details (dispositivo/+/dettagli).

    4. Per ciascuno degli argomenti della tabella precedente, esegui le operazioni seguenti nel client di test MQTT:

      1. In Publish (Pubblica), inserisci il valore dalla colonna Topic name (Nome argomento) nella tabella.

      2. Nel campo del payload del messaggio sotto il nome dell'argomento, inserisci il valore della colonna Message payload (Payload del messaggio) nella tabella.

      3. Guarda la finestra del terminale dove pubsub.py è in esecuzione e, nel client di test MQTT, scegli Publish to topic (Pubblicazione nell'argomento).

      Dovresti vedere che il messaggio è stato ricevuto da pubsub.py nella finestra del terminale.

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

Per valutare l'argomento del messaggio

  1. Copia pubsub.py su pubsub2.py.

  2. Apri pubsub2.py nell'editor di testo preferito o in IDE.

  3. In pubsub2.py, trova la funzione on_message_received.

  4. In on_message_received, inserisci il codice seguente dopo la riga che inizia con print("Received message e prima della riga che inizia con global received_count.

        topic_parsed = False
    if "/" in topic:
        parsed_topic = topic.split("/")
        if len(parsed_topic) == 3:
            # this topic has the correct format
            if (parsed_topic[0] == 'device') and (parsed_topic[2] == 'details'):
                # this is a topic we care about, so check the 2nd element
                if (parsed_topic[1] == 'temp'):
                    print("Received temperature request: {}".format(payload))
                    topic_parsed = True
                if (parsed_topic[1] == 'light'):
                    print("Received light request: {}".format(payload))
                    topic_parsed = True
    if not topic_parsed:
        print("Unrecognized message topic.")

  5. Salva le modifiche ed esegui il programma modificato utilizzando questa riga di comando.

    python3 pubsub2.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint

  6. Nella AWS IoT console, aprite il client di test MQTT.

  7. In Subscribe to a topic (Sottoscrivi un argomento) nel campo Subscription topic field (Argomento sottoscrizione), inserisci il filtro dell’argomento: device/+/details, quindi scegli Subscribe to topic (Sottoscrivi nell’argomento).

  8. Nella colonna Subscriptions (Sottoscrizioni) del client di test MQTT, seleziona device/+/details (dispositivo/+/dettagli).

  9. Per ciascuno degli argomenti di questa tabella, esegui le operazioni seguenti nel client di test MQTT:

    Nome argomento

    Payload del messaggio

    device/temp/details

    { "desiredTemp": 20, "currentTemp": 15 }

    device/light/details

    { "desiredLight": 100, "currentLight": 50 }

    1. In Publish (Pubblica), inserisci il valore dalla colonna Topic name (Nome argomento) nella tabella.

    2. Nel campo del payload del messaggio sotto il nome dell'argomento, inserisci il valore della colonna Message payload (Payload del messaggio) nella tabella.

    3. Guarda la finestra del terminale dove pubsub.py è in esecuzione e, nel client di test MQTT, scegli Publish to topic (Pubblicazione nell'argomento).

    Dovresti vedere che il messaggio è stato ricevuto da pubsub.py nella finestra del terminale.

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. Mentre pubblicherà i messaggi così com’è, i messaggi non possono essere letti come documenti JSON. Questo esercizio modifica l'app di esempio per poter pubblicare documenti JSON nel payload dei messaggi che possono essere letti da. 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 preparare il client di test MQTT per monitorare i messaggi di questo esercizio

  1. In Subscribe to a topic (Sottoscrivi un argomento) nel campo Subscription topic field (Argomento sottoscrizione), inserisci il filtro dell’argomento: device/data, quindi scegli Subscribe to topic (Sottoscrivi nell’argomento).

  2. Nella colonna Subscriptions (Sottoscrizioni) del client di test MQTT, seleziona device/details (dispositivo/dati).

  3. Tieni aperta la finestra del client di test MQTT per attendere i messaggi dal tuo dispositivo.

Per inviare documenti JSON con l'app di esempio pubsub.py

  1. Sul dispositivo, copia pubsub.py su pubsub3.py.

  2. Modifica pubsub3.py per cambiare il modo in cui formatta i messaggi pubblicati.

    1. Aprire pubsub3.py in un editor di testo.

    2. Individua la riga di codice:

      message = "{} [{}]".format(message_string, publish_count)

    3. Modificalo in:

      message = "{}".format(message_string)

    4. Individua la riga di codice:

      message_json = json.dumps(message)

    5. Modificalo in:

      message = "{}".json.dumps(json.loads(message))

    6. Salvare le modifiche.

  3. Sul dispositivo, esegui questo comando per inviare il messaggio due volte.

    python3 pubsub3.py  --ca_file ~/certs/Amazon-root-CA-1.pem  --cert ~/certs/device.pem.crt  --key ~/certs/private.pem.key  --topic device/data  --count 2 --message '{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'  --endpoint your-iot-endpoint

  4. Nel client di test MQTT, verifica che abbia interpretato e formattato il documento JSON nel payload del messaggio, ad esempio:

    Immagine che mostra come viene visualizzato il payload di un messaggio JSON nel client MQTT della console. AWS IoT

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 da elaborare. AWS IoT Core 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: