Prepare seu dispositivo para AWS IoT Revisar o protocolo MQTT Revise o aplicativo de amostra do SDK do dispositivo pubsub.py Conecte seu dispositivo e comunique-se com AWS IoT Core Reveja os resultados

Tutorial: Como conectar um dispositivo AWS IoT Core usando o AWS IoT Device SDK

Este tutorial demonstra como conectar um dispositivo a AWS IoT Core de forma que ele possa enviar e receber dados de e para AWS IoT. Depois de concluir este tutorial, seu dispositivo será configurado para se conectar a AWS IoT Core e você entenderá como os dispositivos se comunicam com AWS IoT.

Neste tutorial, você vai:

Prepare seu dispositivo para AWS IoT
Revisar o protocolo MQTT
Revise o aplicativo de amostra do SDK do dispositivo pubsub.py
Conecte seu dispositivo e comunique-se com AWS IoT Core
Reveja os resultados

A conclusão deste tutorial requer cerca de uma hora.

Antes de começar este tutorial, verifique se você tem o seguinte:

Concluído Começando com AWS IoT Core

Na seção desse tutorial em que você deve Configurar o dispositivo, selecione a opção Conectar um Raspberry Pi ou outro dispositivo para seu dispositivo e use as opções da linguagem Python para configurá-lo.

Mantenha aberta a janela do terminal que você usa nesse tutorial porque você também vai usá-la.
Um dispositivo que pode executar o AWS IoT Device SDK v2 para Python.

Este tutorial mostra como conectar um dispositivo ao AWS IoT Core usando exemplos de código Python, que exigem um dispositivo relativamente poderoso.

Se você estiver trabalhando com dispositivos com recursos limitados, esses exemplos de código podem não funcionar com eles. Nesse caso, talvez você tenha mais sucesso com o Tutorial: Usando o AWS IoT Device SDK para C incorporado tutorial.

Prepare seu dispositivo para AWS IoT

Em Começando com AWS IoT Core, você preparou seu dispositivo e conta AWS para que eles pudessem se comunicar. Esta seção analisa os aspectos dessa preparação que se aplicam a qualquer conexão de dispositivo com AWS IoT Core.

Para que um dispositivo se conecte a AWS IoT Core:

É necessário ter uma Conta da AWS.

O procedimento em Configure seu Conta da AWS descreve como criar um Conta da AWS se você ainda não tiver um.
Nessa conta, você deve ter os seguintes AWS IoT recursos definidos para o dispositivo em sua Conta da AWS e Região.

O procedimento em Crie AWS IoT recursos descreve como criar esses recursos para o dispositivo em sua Conta da AWS e Região.
- Um certificado de dispositivo registrado AWS IoT e ativado para autenticar o dispositivo.
  
  O certificado geralmente é criado com e anexado a um AWS IoT objeto. Embora um objeto não seja necessário para a conexão de um dispositivo ao AWS IoT, ele disponibiliza recursos AWS IoT adicionais para o dispositivo.
- Uma política anexada ao certificado do dispositivo que o autoriza a se conectar AWS IoT Core e realizar todas as ações desejadas.
Uma conexão com a Internet que pode acessar os endpoints Conta da AWS do seu dispositivo.

Os endpoints do dispositivo estão descritos AWS IoT dados do dispositivo e endpoints de serviço e podem ser vistos na página de configurações do AWS IoT console.
Software de comunicação, como o AWS IoT Device SDKs fornece. Este tutorial usa o AWS IoT Device SDK v2 para Python.

Revisar o protocolo MQTT

Antes de falarmos sobre o aplicativo de exemplo, é útil entender o protocolo MQTT. O protocolo MQTT oferece algumas vantagens sobre outros protocolos de comunicação de rede, como o HTTP, o que o torna uma escolha popular para dispositivos IoT. Esta seção analisa os principais aspectos do MQTT que se aplicam a este tutorial. Para obter informações sobre como o MQTT se compara ao HTTP, consulte Escolher um protocolo para a comunicação do seu dispositivo.

O MQTT usa um modelo de comunicação de publicação/assinatura

O protocolo MQTT usa um modelo de comunicação de publicação/assinatura com seu host. Esse modelo difere do modelo de solicitação/resposta que o HTTP usa. Com o MQTT, os dispositivos estabelecem uma sessão com o host que é identificado por um ID de cliente exclusivo. Para enviar dados, os dispositivos publicam mensagens identificadas por tópicos para um agente de mensagens no host. Para receber mensagens do agente de mensagens, os dispositivos assinam tópicos enviando filtros de tópicos em solicitações de assinatura ao agente de mensagens.

O MQTT é compatível com sessões persistentes

O agente de mensagens recebe mensagens de dispositivos e publica mensagens em dispositivos que as assinaram. Com sessões persistentes —sessões que permanecem ativas mesmo quando o dispositivo iniciador está desconectado — os dispositivos podem recuperar mensagens que foram publicadas enquanto estavam desconectados. No lado do dispositivo, o MQTT é compatível com níveis de Qualidade de Serviço (QoS) que garantem que o host receba mensagens enviadas pelo dispositivo.

Revise o aplicativo de amostra do SDK do dispositivo pubsub.py

Esta seção analisa o aplicativo de amostra pubsub.py do AWS IoT Device SDK v2 para Python usado neste tutorial. Aqui, analisaremos como ele se conecta AWS IoT Core para publicar e assinar mensagens do MQTT. A próxima seção apresenta alguns exercícios para ajudar você a explorar como um dispositivo se conecta e se comunica com AWS IoT Core.

O aplicativo pubsub.py de amostra demonstra esses aspectos de uma conexão MQTT com: AWS IoT Core

Protocolos de comunicação
Sessões persistentes
Qualidade do serviço
Publicação de mensagens
Assinatura de mensagens
Desconexão e reconexão do dispositivo

Protocolos de comunicação

A amostra pubsub.py demonstra uma conexão MQTT usando os protocolos MQTT e MQTT via WSS. A biblioteca AWS common runtime (AWS CRT) fornece suporte ao protocolo de comunicação de baixo nível e está incluída no AWS IoT Device SDK v2 para Python.

MQTT

As pubsub.py chamadas de amostra mtls_from_path (mostradas aqui) em mqtt_connection_builder para estabelecer uma conexão com AWS IoT Core usando o protocolo MQTT. O mtls_from_path usa certificados X.509 e TLS v1.2 para autenticar o dispositivo. A AWS biblioteca CRT trata dos detalhes de nível inferior dessa conexão.


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

O Conta da AWS endpoint do seu dispositivo de IoT

No aplicativo de amostra, esse valor é passado pela linha de comando.

cert_filepath

O caminho para o arquivo de certificado do dispositivo

No aplicativo de amostra, esse valor é passado pela linha de comando.

pri_key_filepath

O caminho para o arquivo de chave privada do dispositivo que foi criado com seu arquivo de certificado

No aplicativo de amostra, esse valor é passado pela linha de comando.

ca_filepath

O caminho para o arquivo CA Raiz. Obrigatório somente se o servidor MQTT usar um certificado que ainda não esteja em seu armazenamento confiável.

No aplicativo de amostra, esse valor é passado pela linha de comando.

client_bootstrap

O objeto de runtime comum que trata as atividades de comunicação por soquete

No aplicativo de amostra, esse objeto é instanciado antes da chamada para mqtt_connection_builder.mtls_from_path.

on_connection_interrupted

on_connection_resumed

As funções de retorno de chamada para chamar quando a conexão do dispositivo for interrompida e retomada

client_id

O ID que identifica exclusivamente esse dispositivo no Região da AWS

No aplicativo de amostra, esse valor é passado pela linha de comando.

clean_session

Se deve iniciar uma nova sessão persistente ou, se houver uma, se reconectar a uma existente

keep_alive_secs

O valor keep alive, em segundos, a ser enviado na CONNECT solicitação. Um ping será enviado automaticamente nesse intervalo. Se o servidor não receber um ping após 1,5 vezes esse valor, ele assume que a conexão foi perdida.

MQTT via WSS

As pubsub.py chamadas de amostra websockets_with_default_aws_signing (mostradas aqui) no mqtt_connection_builder para estabelecer uma conexão com AWS IoT Core usando o protocolo MQTT via WSS. websockets_with_default_aws_signing cria uma conexão MQTT via WSS usando Signature V4 para autenticar o 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

O Conta da AWS endpoint do seu dispositivo de IoT

No aplicativo de amostra, esse valor é passado pela linha de comando.

client_bootstrap

O objeto de runtime comum que trata as atividades de comunicação por soquete

No aplicativo de amostra, esse objeto é instanciado antes da chamada para mqtt_connection_builder.websockets_with_default_aws_signing.

region

A região de assinatura AWS usada pela autenticação Signature V4. Em pubsub.py, ele passa o parâmetro inserido na linha de comando.

No aplicativo de amostra, esse valor é passado pela linha de comando.

credentials_provider

As AWS credenciais fornecidas para uso na autenticação

No aplicativo de amostra, esse objeto é instanciado antes da chamada para mqtt_connection_builder.websockets_with_default_aws_signing.

websocket_proxy_options

Opções de proxy HTTP, se estiver usando um host proxy

No aplicativo de amostra, esse valor é inicializado antes da chamada para mqtt_connection_builder.websockets_with_default_aws_signing.

ca_filepath

O caminho para o arquivo CA Raiz. Obrigatório somente se o servidor MQTT usar um certificado que ainda não esteja em seu armazenamento confiável.

No aplicativo de amostra, esse valor é passado pela linha de comando.

on_connection_interrupted

on_connection_resumed

As funções de retorno de chamada para chamar quando a conexão do dispositivo for interrompida e retomada

client_id

O ID que identifica exclusivamente esse dispositivo no Região da AWS.

No aplicativo de amostra, esse valor é passado pela linha de comando.

clean_session

Se deve iniciar uma nova sessão persistente ou, se houver uma, se reconectar a uma existente

keep_alive_secs

HTTPS

E quanto ao HTTPS? AWS IoT Core oferece suporte a dispositivos que publicam solicitações HTTPS. Do ponto de vista da programação, os dispositivos enviam solicitações HTTPS para AWS IoT Core o mesmo que qualquer outro aplicativo. Para ver um exemplo de um programa em Python que envia uma mensagem HTTP de um dispositivo, consulte o exemplo de código HTTPS usando a biblioteca do Python. requests Este exemplo envia uma mensagem para AWS IoT Core usando o HTTPS de forma que a AWS IoT Core o interprete como uma mensagem MQTT.

Embora AWS IoT Core ofereça suporte a solicitações HTTPS de dispositivos, certifique-se de revisar as informações Escolher um protocolo para a comunicação do seu dispositivo para que você possa tomar uma decisão informada sobre qual protocolo usar para as comunicações do seu dispositivo.

Sessões persistentes

No aplicativo de amostra, definir o parâmetro clean_session como False indica que a conexão deve ser persistente. Na prática, a conexão aberta por essa chamada se reconecta a uma sessão persistente existente, se houver. Caso contrário, ela cria e se conecta a uma nova sessão persistente.

Com uma sessão persistente, as mensagens enviadas ao dispositivo são armazenadas pelo agente de mensagens enquanto o dispositivo não está conectado. Quando um dispositivo se reconecta a uma sessão persistente, o agente de mensagens envia ao dispositivo todas as mensagens armazenadas nas quais ele se inscreveu.

Sem uma sessão persistente, o dispositivo não receberá mensagens enviadas enquanto o dispositivo não estiver conectado. A opção a ser usada depende do seu aplicativo e se as mensagens que ocorrem enquanto um dispositivo não está conectado devem ser comunicadas. Para obter mais informações, consulte Sessões persistentes do MQTT.

Qualidade do serviço

Quando o dispositivo publica e assina mensagens, a Qualidade de Serviço (QoS) preferida pode ser definida. AWS IoT é compatível com os níveis de QoS 0 e 1 para operações de publicação e assinatura. Para obter mais informações sobre os níveis de QoS no AWS IoT, consulte Opções de Qualidade de serviço (QoS) do MQTT.

O AWS runtime do CRT para Python define essas constantes para os níveis de QoS que ele suporta:

Níveis de qualidade de serviço do Python
Nível de QoS do MQTT	Valor simbólico do Python usado pelo SDK	Descrição
QoS nível 0	`mqtt.QoS.AT_MOST_ONCE`	Somente uma tentativa de enviar a mensagem será feita, seja ela recebida ou não. A mensagem pode não ser enviada, por exemplo, se o dispositivo não estiver conectado ou houver um erro na rede.
QoS nível 1	`mqtt.QoS.AT_LEAST_ONCE`	A mensagem é enviada repetidamente até que uma `PUBACK` confirmação seja recebida.

No aplicativo de amostra, as solicitações de publicação e assinatura são feitas com um nível de QoS de 1 (mqtt.QoS.AT_LEAST_ONCE).

QoS na publicação

Quando um dispositivo publica uma mensagem com QoS nível 1, ele envia a mensagem repetidamente até receber uma PUBACK resposta do agente de mensagens. Se o dispositivo não estiver conectado, a mensagem será colocada na fila para ser enviada após a reconexão.
QoS na assinatura

Quando um dispositivo assina uma mensagem com QoS nível 1, o agente de mensagens salva as mensagens nas quais o dispositivo está inscrito até que elas possam ser enviadas ao dispositivo. O agente de mensagens reenvia as mensagens até receber uma resposta PUBACK do dispositivo.

Publicação de mensagens

Depois de estabelecer com sucesso uma conexão com AWS IoT Core, os dispositivos podem publicar mensagens. A amostra pubsub.py faz isso chamando a operação publish do mqtt_connection objeto.


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

topic

O nome do tópico da mensagem que identifica a mensagem

No aplicativo de amostra, esse valor é passado pela linha de comando.

payload

A carga útil da mensagem formatada como uma string (por exemplo, um documento JSON)

No aplicativo de amostra, esse valor é passado pela linha de comando.

Um documento JSON é um formato de carga útil comum e reconhecido por outros AWS IoT serviços; no entanto, o formato de dados da carga útil da mensagem pode ser qualquer objeto com a qual os publicadores e assinantes concordem. Outros AWS IoT serviços, no entanto, reconhecem apenas JSON e CBOR, em alguns casos, para a maioria das operações.

qos

O nível de QoS para esta mensagem

Para receber mensagens de AWS IoT outros serviços e dispositivos, os dispositivos assinam essas mensagens pelo nome do tópico. Os dispositivos podem assinar mensagens individuais especificando um nome de tópico e em um grupo de mensagens especificando um filtro de tópico, que pode incluir caracteres curinga. A amostra pubsub.py usa o código mostrado aqui para assinar mensagens e registrar as funções de retorno de chamada para processar a mensagem depois de recebida.


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

Como assinar um tópico do. Pode ser um nome de tópico ou um filtro de tópico.

No aplicativo de amostra, esse valor é passado pela linha de comando.

qos

Se o agente de mensagens deve armazenar essas mensagens enquanto o dispositivo está desconectado.

Um valor de mqtt.QoS.AT_LEAST_ONCE (QoS nível 1) exige que uma sessão persistente seja especificada (clean_session=False) quando a conexão é criada.

callback

A função a ser chamada para processar a mensagem assinada.

A função mqtt_connection.subscribe retorna um future e um ID de pacote. Se a solicitação de assinatura foi iniciada com sucesso, o ID do pacote retornado será maior que 0. Para garantir que a assinatura tenha sido recebida e registrada pelo agente de mensagens, você deve aguardar o retorno do resultado da operação assíncrona, conforme mostrado no exemplo de código.

Função de retorno de chamada

O retorno de chamada na amostra pubsub.py processa as mensagens assinadas à medida que o dispositivo as recebe.


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

O tópico da mensagem

Esse é o nome do tópico específico da mensagem recebida, mesmo que você tenha se inscrito em um filtro de tópicos.

payload

Carga útil da mensagem

O formato para isso é específico do aplicativo.

kwargs

Possíveis argumentos adicionais, conforme descrito em mqtt.Connection.subscribe.

Na amostra pubsub.py, on_message_received exibe somente o tópico e sua carga útil. Ele também conta as mensagens recebidas para finalizar o programa após o limite ser atingido.

Seu aplicativo avaliaria o tópico e a carga para determinar quais ações realizar.

Desconexão e reconexão do dispositivo

A amostra pubsub.py inclui funções de retorno de chamada que são chamadas quando o dispositivo é desconectado e quando a conexão é restabelecida. As ações que seu dispositivo executa nesses eventos são específicas do aplicativo.

Quando um dispositivo se conecta pela primeira vez, ele precisa se inscrever nos tópicos para receber. Se a sessão de um dispositivo estiver presente quando ele se reconectar, suas assinaturas serão restauradas e todas as mensagens armazenadas dessas assinaturas serão enviadas ao dispositivo após a reconexão.

Se a sessão de um dispositivo não existir mais quando ele se reconectar, ele deverá assinar novamente suas assinaturas. As sessões persistentes têm uma vida útil limitada e podem expirar quando o dispositivo é desconectado por muito tempo.

Conecte seu dispositivo e comunique-se com AWS IoT Core

Esta seção apresenta alguns exercícios para ajudá-lo a explorar diferentes aspectos da conexão do seu dispositivo a AWS IoT Core. Para esses exercícios, você usará o cliente de teste MQTT no AWS IoT console para ver o que seu dispositivo publica e publicar mensagens em seu dispositivo. Esses exercícios usam a pubsub.py amostra do AWS IoT Device SDK v2 para Python e se baseiam na sua experiência com tutoriais. Começando com AWS IoT Core

Nesta seção:

Inscreva-se nos filtros de tópicos curinga
Processar assinaturas de filtros de tópicos
Publique mensagens do seu dispositivo

Para esses exercícios, você começará com o programa pubsub.py de amostra.

nota

Esses exercícios pressupõem que você concluiu os Começando com AWS IoT Core tutoriais e usou a janela do terminal do seu dispositivo a partir desse tutorial.

Inscreva-se nos filtros de tópicos curinga

Neste exercício, você modificará a linha de comando usada para chamar pubsub.py para assinar um filtro de tópico curinga e processará as mensagens recebidas com base no tópico da mensagem.

Procedimento de exercício

Para este exercício, imagine que seu dispositivo contenha um controle de temperatura e um controle de luz. Ele usa esses nomes de tópicos para identificar as mensagens sobre eles.

Antes de iniciar o exercício, tente executar esse comando nos Começando com AWS IoT Core tutoriais do seu dispositivo para garantir que tudo esteja pronto para o exercício.
```
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
```
Você deve ver a mesma saída que viu no tutorial de introdução.

Para este exercício, altere esses parâmetros da linha de comando.

Ação	Parâmetro da linha de comando	Efeito
adicionar	--message `""`	Configure `pubsub.py` para ouvir somente
adicionar	--count `2`	Encerre o programa depois de receber duas mensagens
alteração	--topic `device/+/details`	Defina o filtro de tópicos para se inscrever em

Fazer essas alterações na linha de comando inicial resulta nessa linha de comando. Digite esse comando na janela do terminal do seu 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

O programa deve exibir algo semelhante ao seguinte:


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 você vir algo assim em seu terminal, seu dispositivo está pronto e ouvindo mensagens onde os nomes dos tópicos começam com device e terminam com /detail. Então, vamos testar isso.

Aqui estão algumas mensagens que seu dispositivo pode receber.

Nome do tópico	Carga útil da mensagem
`device/temp/details`	`{ "desiredTemp": 20, "currentTemp": 15 }`
`device/light/details`	`{ "desiredLight": 100, "currentLight": 50 }`

Usando o cliente de teste MQTT no console AWS IoT, envie as mensagens descritas na etapa anterior para o seu dispositivo.
1. Abra o cliente de teste MQTT no AWS IoT console.
2. Em Inscrever-se em um tópico, no campo assinatura do tópico, insira o filtro do tópico: device/+/details e, em seguida, selecione Inscreva-se no tópico.
3. Na coluna Assinaturas do cliente de teste MQTT, escolha dispositivo/+/detalhes.
4. Para cada um dos tópicos na tabela anterior, faça o seguinte no cliente de teste do MQTT:
  1. Em Publicar, insira o valor da coluna Nome do tópico na tabela.
  2. No campo de carga útil da mensagem abaixo do nome do tópico, insira o valor da coluna Carga útil da mensagem na tabela.
  3. Observe a janela do terminal em que pubsub.py está sendo executada e, no cliente de teste do MQTT, escolha Publicar no tópico.
  Você deve ver que a mensagem foi recebida pubsub.py na janela do terminal.

Resultado do exercício

Com isso, pubsub.py, assinou as mensagens usando um filtro de tópico curinga, recebeu-as e as exibiu na janela do terminal. Observe como você se inscreveu em um único filtro de tópico e a função de retorno de chamada foi chamada para processar mensagens com dois tópicos distintos.

Processar assinaturas de filtros de tópicos

Com base no exercício anterior, modifique o aplicativo de pubsub.py amostra para avaliar os tópicos da mensagem e processar as mensagens inscritas com base no tópico.

Procedimento de exercício

Para avaliar o tópico da mensagem

Copie pubsub.py para pubsub2.py.
Abra pubsub2.py no seu editor de texto favorito ou IDE.
Em pubsub2.py, encontre a função on_message_received.

Em on_message_received, insira o código a seguir após a linha que começa com print("Received message e antes da linha que começa com 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.")

Salve suas alterações e execute o programa modificado usando essa linha de 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

No AWS IoT console, abra o cliente de teste MQTT.
Em Inscrever-se em um tópico, no campo assinatura do tópico, insira o filtro do tópico: device/+/details e, em seguida, selecione Inscreva-se no tópico.
Na coluna Assinaturas do cliente de teste MQTT, selecione dispositivo/+/detalhes.

Para cada um dos tópicos nesta tabela, faça o seguinte no cliente de teste do MQTT:

Nome do tópico	Carga útil da mensagem
`device/temp/details`	`{ "desiredTemp": 20, "currentTemp": 15 }`
`device/light/details`	`{ "desiredLight": 100, "currentLight": 50 }`

Em Publicar, insira o valor da coluna Nome do tópico na tabela.
No campo de carga útil da mensagem abaixo do nome do tópico, insira o valor da coluna Carga útil da mensagem na tabela.
Observe a janela do terminal em que pubsub.py está sendo executada e, no cliente de teste do MQTT, escolha Publicar no tópico.

Você deve ver que a mensagem foi recebida pubsub.py na janela do terminal.

Você deverá ver algo semelhante a isso na janela do seu terminal.


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!

Resultado do exercício

Neste exercício, você adicionou código para que o aplicativo de amostra reconheça e processe várias mensagens na função de retorno de chamada. Com isso, seu dispositivo pode receber mensagens e agir conforme elas.

Outra forma de seu dispositivo receber e processar várias mensagens é assinar mensagens diferentes separadamente e atribuir a cada assinatura sua própria função de retorno de chamada.

Publique mensagens do seu dispositivo

Você pode usar o aplicativo de amostra pubsub.py para publicar mensagens do seu dispositivo. Embora publique as mensagens como estão, elas não podem ser lidas como documentos JSON. Este exercício modifica o aplicativo de amostra para poder publicar documentos JSON na carga útil da mensagem que podem ser lidos por AWS IoT Core.

Procedimento de exercício

Neste exercício, a seguinte mensagem será enviada com o tópico device/data.


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

Para preparar seu cliente de teste MQTT para monitorar as mensagens deste exercício

Em Inscrever-se em um tópico, no campo assinatura do tópico, insira o filtro do tópico: device/data e, em seguida, selecione Inscreva-se no tópico.
Na coluna Assinaturas do cliente de teste MQTT, selecione dispositivo/dados.
Mantenha a janela do cliente de teste MQTT aberta para aguardar as mensagens do seu dispositivo.

Para enviar documentos JSON com o aplicativo de amostra pubsub.py

No seu dispositivo, copie pubsub.py para pubsub3.py.
Edite pubsub3.py para alterar a forma como ele formata as mensagens que publica.
1. Abra pubsub3.py em um editor de texto.
2. Localize esta linha de código:
  
  message = "{} [{}]".format(message_string, publish_count)
3. Altere para:
  
  message = "{}".format(message_string)
4. Localize esta linha de código:
  
  message_json = json.dumps(message)
5. Altere para:
  
  message = "{}".json.dumps(json.loads(message))
6. Salve as alterações.

No seu dispositivo, execute esse comando para enviar a mensagem duas vezes.


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

No cliente de teste MQTT, verifique se ele interpretou e formatou o documento JSON na carga útil da mensagem, da seguinte forma:

Por padrão, pubsub3.py também assina as mensagens que envia. Você deve ver que ele recebeu as mensagens na saída do aplicativo. A janela do terminal deve parecer com algo semelhante ao seguinte.


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!

Resultado do exercício

Com isso, seu dispositivo pode gerar mensagens para enviar AWS IoT Core para testar a conectividade básica e fornecer mensagens do dispositivo para AWS IoT Core processar. Por exemplo, você pode usar esse aplicativo para enviar dados de teste do seu dispositivo para testar AWS IoT ações de regras.

Reveja os resultados

Os exemplos deste tutorial proporcionaram a você uma experiência prática com os conceitos básicos de como os dispositivos podem se comunicar AWS IoT Core — uma parte fundamental de sua AWS IoT solução. Quando seus dispositivos conseguem se comunicar com AWS IoT Core, eles podem passar mensagens para AWS serviços e outros dispositivos nos quais possam atuar. Da mesma forma, AWS serviços e outros dispositivos podem processar informações que resultam em mensagens enviadas de volta aos seus dispositivos.

Quando estiver pronto para explorar AWS IoT Core mais, experimente estes tutoriais:

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Criação de soluções com os AWS IoT Device SDKs

Usando o AWS IoT Device SDK para C incorporado

Tutorial: Como conectar um dispositivo AWS IoT Core usando o AWS IoT Device SDK

Antes de começar este tutorial, verifique se você tem o seguinte:

Concluído Começando com AWS IoT Core

Um dispositivo que pode executar o AWS IoT Device SDK v2 para Python.

Prepare seu dispositivo para AWS IoT

Revisar o protocolo MQTT

O MQTT usa um modelo de comunicação de publicação/assinatura

O MQTT é compatível com sessões persistentes

Revise o aplicativo de amostra do SDK do dispositivo pubsub.py

O aplicativo pubsub.py de amostra demonstra esses aspectos de uma conexão MQTT com: AWS IoT Core

Protocolos de comunicação

MQTT

MQTT via WSS

HTTPS

Sessões persistentes

Qualidade do serviço

QoS na publicação

QoS na assinatura

Publicação de mensagens

Assinatura de mensagens

Função de retorno de chamada

Desconexão e reconexão do dispositivo

Conecte seu dispositivo e comunique-se com AWS IoT Core

Nesta seção:

nota

Inscreva-se nos filtros de tópicos curinga

Procedimento de exercício

Resultado do exercício

Processar assinaturas de filtros de tópicos

Procedimento de exercício

Para avaliar o tópico da mensagem

Resultado do exercício

Publique mensagens do seu dispositivo

Procedimento de exercício

Para preparar seu cliente de teste MQTT para monitorar as mensagens deste exercício

Para enviar documentos JSON com o aplicativo de amostra pubsub.py

Resultado do exercício

Reveja os resultados