Tutorial: Connessione di un dispositivo a AWS IoT Core utilizzando SDK per dispositivi AWS IoT - AWS IoT Core
Prepara il dispositivo per AWS IoTEsamina il protocollo MQTTRevisione dell'app di esempio pubsub.py SDK per dispositiviConnessione del dispositivo e comunicazione 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 a AWS IoT Core utilizzando SDK per dispositivi AWS IoT

In questo tutorial viene illustrato come collegare un dispositivo a AWS IoT Core in modo che possa inviare e ricevere dati da e verso AWS IoT. Una volta completato il tutorial, il dispositivo verrà configurato per connettersi a AWS IoT Core e capirai come i dispositivi comunicano con AWS IoT.

In questo tutorial, verranno eseguite le operazioni seguenti:

  1. Prepara il dispositivo per AWS IoT

  2. Esamina il protocollo MQTT

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

  4. Connessione del dispositivo e comunicazione con AWS IoT Core

  5. Rivedi i risultati

Questo tutorial dura circa un’ora.

Prima di iniziare il tutorial, assicurati di disporre:
  • Aver completato Nozioni di base su AWS IoT Core

    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.

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

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

    In questo tutorial viene illustrato come connettere un dispositivo ad 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 Tutorial: Utilizzo del SDK per dispositivi AWS IoT per Embedded C.

Prepara il dispositivo per AWS IoT

In Nozioni di base su AWS IoT Core, hai preparato il tuo dispositivo e account AWS in modo che potessero comunicare. Questa sezione esamina gli aspetti di tale preparazione che si applicano a qualsiasi connessione del dispositivo con AWS IoT Core.

Affinché un dispositivo si connetta a AWS IoT Core:

  1. È necessario disporre di un Account AWS.

    La procedura in Configura il tuo Account AWS descrive come creare un account Account AWS se non disponi già di uno.

  2. In tale account, devi disporre delle seguenti risorse AWS IoT definite per il dispositivo nell’account Account AWS e 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. Un oggetto non è richiesto a un dispositivo per connettersi a AWS IoT ma rende le funzioni aggiuntive AWS IoT disponibili per il dispositivo.

    • Una policy collegata al certificato del dispositivo che lo autorizza a connettersi a AWS IoT Core ed eseguire tutte le operazioni che si desidera.

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

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

  4. Software di comunicazione come fornisce il SDK per dispositivi AWS IoT. 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 Scegliere un protocollo per la comunicazione del dispositivo.

MQTT utilizza un modello di comunicazione pubblica/sottoscrivi

Il protocollo MQTT utilizza un modello di comunicazione pubblica/sottoscrivi con il relativo host. Questo modello differisce dal modello di richiesta/risposta 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 a AWS IoT Core per pubblicare e sottoscrivere messaggi MQTT. Nella sezione successiva vengono presentati alcuni esercizi che consentono di esplorare il modo in cui un dispositivo si connette e comunica con AWS IoT Core.

Protocolli di comunicazione

L’esempio pubsub.py illustra una connessione MQTT utilizzando i protocolli MQTT e MQTT su WSS. Il AWS runtime comune (CRT AWS) fornisce il supporto del protocollo di comunicazione di basso livello ed è incluso con il SDK per dispositivi AWS IoT v2 per Python.

MQTT

L'esempio pubsub.py chiama mtls_from_path (mostrato qui) in mqtt_connection_builder per stabilire una connessione con AWS IoT Core utilizzando il protocollo MQTT. mtls_from_path utilizza i certificati X.509 e TLS v1.2 per autenticare il dispositivo. La libreria CRT AWS 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 del dispositivo IoT Account AWS

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 del dispositivo IoT Account AWS

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 firmataria AWS utilizzata dall'autenticazione Firma 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 credenziali AWS 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

Per quanto riguarda il protocollo HTTPS? AWS IoT Core supporta i 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. In questo esempio viene inviato un messaggio a AWS IoT Core utilizzando HTTPS in modo tale che AWS IoT Core lo interpreti come un messaggio MQTT.

AWS IoT Core supporta le richieste HTTPS dai dispositivi ma assicurati di rivedere le informazioni su Scegliere un protocollo per la comunicazione del dispositivo in modo da poter prendere una decisione informata sul protocollo da utilizzare per le comunicazioni del dispositivo.

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 si sottoscrive ai 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 su AWS IoT, consulta Opzioni di qualità del servizio MQTT (QoS).

Il runtime CRT AWS 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 uno riconosciuto da altri servizi AWS IoT; tuttavia, il formato dei dati del payload dei messaggi può essere tutto ciò che gli editori e gli abbonati concordano. 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 sottoscrivono 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.

Connessione del dispositivo e comunicazione 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 Nozioni di base su AWS IoT Core.

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

Nota

Questi esercizi presuppongono che tu abbia completato i tutorial Nozioni di base su AWS IoT Core 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 Nozioni di base su AWS IoT Core 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.

    Operazione

    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 console AWS IoT, invia i messaggi descritti nel passaggio precedente al dispositivo.

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

    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 yo topic (Pubblica 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 console AWS IoT, apri 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 yo topic (Pubblica 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 un payload del 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

Con questo, il dispositivo può generare messaggi da inviare a AWS IoT Core per testare la connettività di base e fornire messaggi sui dispositivi per farli elaborare a AWS IoT Core. Ad esempio, puoi usare questa app per inviare dati di test dal tuo dispositivo per testare le operazioni delle regole AWS IoT.

Rivedi i risultati

Gli esempi in questo tutorial ti hanno offerto un'esperienza pratica con le nozioni di base su come i dispositivi possono comunicare con AWS IoT Core, una parte fondamentale della soluzione AWS IoT. Quando i dispositivi sono in grado di comunicare con AWS IoT Core, possono passare messaggi ai servizi AWS e ad altri dispositivi su cui possono agire. Allo stesso modo, i servizi AWS e altri dispositivi possono elaborare informazioni che si traducono in messaggi inviati ai tuoi dispositivi.

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