weslleylmurdock
3 years ago
parent
c0b40671ce
commit
8d060c3b55
@ -0,0 +1,455 @@
|
||||
# Conecte seu dispositivo à Internet
|
||||
|
||||
|
||||
|
||||
> Sketchnote por [Nitya Narasimhan](https://github.com/nitya). Clique na imagem para uma versão maior.
|
||||
|
||||
Esta lição foi ministrada como parte da [série Hello IoT](https://youtube.com/playlist?list=PLmsFUfdnGr3xRts0TIwyaHyQuHaNQcb6-) do [Microsoft Reactor](https://developer.microsoft.com/reactor/?WT .mc_id=academic-17441-jabenn). A aula foi ministrada em 2 vídeos - uma aula de 1 hora e uma hora de expediente de 1 hora, mergulhando mais profundamente em partes da aula e respondendo a perguntas.
|
||||
|
||||
[](https://youtu.be/O4dd172mZhs)
|
||||
|
||||
[](https://youtu.be/j-cVCzRDE2Q )
|
||||
|
||||
> 🎥 Clique nas imagens acima para assistir aos vídeos
|
||||
|
||||
## Teste pré-aula
|
||||
|
||||
[Teste pré-aula](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/7)
|
||||
|
||||
## Introdução
|
||||
|
||||
O **I** em IoT significa **Internet** - a conectividade em nuvem e os serviços que permitem muitos dos recursos dos dispositivos IoT, desde a coleta de medições dos sensores conectados ao dispositivo até o envio de mensagens para controlar os atuadores . Os dispositivos de IoT normalmente se conectam a um único serviço de IoT em nuvem usando um protocolo de comunicação padrão, e esse serviço é conectado ao restante de seu aplicativo de IoT, desde serviços de IA para tomar decisões inteligentes sobre seus dados até aplicativos da Web para controle ou geração de relatórios.
|
||||
|
||||
> 🎓 Os dados coletados de sensores e enviados para a nuvem são chamados de telemetria.
|
||||
|
||||
Os dispositivos IoT podem receber mensagens da nuvem. Muitas vezes, as mensagens contêm comandos - ou seja, instruções para executar uma ação internamente (como reinicializar ou atualizar o firmware) ou usando um atuador (como acender uma luz).
|
||||
|
||||
Esta lição apresenta alguns dos protocolos de comunicação que os dispositivos IoT podem usar para se conectar à nuvem e os tipos de dados que eles podem enviar ou receber. Você também terá experiência com ambos, adicionando controle de internet à sua luz noturna, movendo a lógica de controle de LED para o código 'servidor' executado localmente.
|
||||
|
||||
Nesta lição abordaremos:
|
||||
|
||||
* [Protocolos de comunicação](#protocolos-de-comunicação)
|
||||
* [Message Queueing Telemetry Transport (MQTT)](#message-queueing-telemetry-transport-mqtt)
|
||||
* [Telemetria](#telemetria)
|
||||
* [Commands](#commands)
|
||||
|
||||
## Protocolos de comunicação
|
||||
|
||||
Existem vários protocolos de comunicação populares usados por dispositivos IoT para se comunicar com a Internet. Os mais populares são baseados em mensagens de publicação/assinatura por meio de algum tipo de corretor. Os dispositivos IoT se conectam ao broker e publicam telemetria e assinam comandos. Os serviços de nuvem também se conectam ao broker e assinam todas as mensagens de telemetria e publicam comandos para dispositivos específicos ou para grupos de dispositivos.
|
||||
|
||||
|
||||
|
||||
O MQTT é o protocolo de comunicação mais popular para dispositivos IoT e é abordado nesta lição. Outros protocolos incluem AMQP e HTTP/HTTPS.
|
||||
|
||||
## Message Queueing Telemetry Transport (MQTT)
|
||||
|
||||
[MQTT](http://mqtt.org) é um protocolo de mensagens padrão aberto e leve que pode enviar mensagens entre dispositivos. Ele foi projetado em 1999 para monitorar oleodutos, antes de ser lançado como um padrão aberto 15 anos depois pela IBM.
|
||||
|
||||
O MQTT possui um único broker e vários clientes. Todos os clientes se conectam ao broker e o broker roteia mensagens para os clientes relevantes. As mensagens são roteadas usando tópicos nomeados, em vez de serem enviadas diretamente para um cliente individual. Um cliente pode publicar em um tópico e qualquer cliente que se inscrever nesse tópico receberá a mensagem.
|
||||
|
||||
|
||||
|
||||
✅ Pesquise. Se você tiver muitos dispositivos IoT, como garantir que seu agente MQTT possa lidar com todas as mensagens?
|
||||
|
||||
### Conecte seu dispositivo IoT ao MQTT
|
||||
|
||||
A primeira parte de adicionar o controle da Internet ao seu nightlight é conectá-lo a um broker MQTT.
|
||||
|
||||
#### Tarefa
|
||||
|
||||
Conecte seu dispositivo a um broker MQTT.
|
||||
|
||||
Nesta parte da lição, você conectará sua luz noturna IoT à Internet para permitir que ela seja controlada remotamente. Mais adiante nesta lição, seu dispositivo IoT enviará uma mensagem de telemetria por MQTT para um broker MQTT público com o nível leve, onde será captado por algum código de servidor que você escreverá. Este código verificará o nível de luz e enviará uma mensagem de comando de volta ao dispositivo, informando-o para ligar ou desligar o LED.
|
||||
|
||||
O caso de uso do mundo real para essa configuração pode ser coletar dados de vários sensores de luz antes de decidir acender as luzes, em um local com muitas luzes, como um estádio. Isso poderia impedir que as luzes fossem acesas se apenas um sensor estivesse coberto por nuvens ou um pássaro, mas os outros sensores detectassem luz suficiente.
|
||||
|
||||
✅ Que outras situações exigiriam que os dados de vários sensores fossem avaliados antes de enviar comandos?
|
||||
|
||||
Em vez de lidar com as complexidades de configurar um corretor MQTT como parte desta tarefa, você pode usar um servidor de teste público que executa o [Eclipse Mosquitto](https://www.mosquitto.org), um corretor MQTT de código aberto. Este corretor de teste está disponível publicamente em [test.mosquitto.org](https://test.mosquitto.org) e não requer que uma conta seja configurada, tornando-se uma ótima ferramenta para testar clientes e servidores MQTT.
|
||||
|
||||
> 💁 Este corretor de teste é público e não seguro. Qualquer pessoa pode estar ouvindo o que você publica, portanto, não deve ser usado com nenhum dado que precise ser mantido privado
|
||||
|
||||
|
||||
|
||||
Siga a etapa relevante abaixo para conectar seu dispositivo ao broker MQTT:
|
||||
|
||||
* [Arduino - Terminal Wio](wio-terminal-mqtt.md)
|
||||
* [Computador de placa única - dispositivo Raspberry Pi/Virtual IoT](computador de placa única-mqtt.md)
|
||||
|
||||
### Um mergulho mais profundo no MQTT
|
||||
|
||||
Os tópicos podem ter uma hierarquia e os clientes podem se inscrever em diferentes níveis da hierarquia usando curingas. Por exemplo, você pode enviar mensagens de telemetria de temperatura para o tópico `/telemetry/temperature` e mensagens de umidade para o tópico `/telemetry/humidity`. mensagens de telemetria de temperatura e umidade.
|
||||
|
||||
As mensagens podem ser enviadas com uma qualidade de serviço (QoS), que determina a garantia do recebimento da mensagem.
|
||||
|
||||
* No máximo uma vez - a mensagem é enviada apenas uma vez e o cliente e o corretor não realizam etapas adicionais para confirmar a entrega (disparar e esquecer).
|
||||
* Pelo menos uma vez - a mensagem é repetida pelo remetente várias vezes até que a confirmação seja recebida (entrega confirmada).
|
||||
* Exatamente uma vez - o remetente e o destinatário realizam um handshake de dois níveis para garantir que apenas uma cópia da mensagem seja recebida (entrega garantida).
|
||||
|
||||
✅ Que situações podem exigir uma mensagem de entrega garantida sobre uma mensagem de incêndio e esquecimento?
|
||||
|
||||
Embora o nome seja Enfileiramento de Mensagens (iniciais em MQTT), na verdade ele não oferece suporte a filas de mensagens. Isso significa que se um cliente se desconectar e depois se reconectar, ele não receberá mensagens enviadas durante a desconexão, exceto aquelas mensagens que ele já havia começado a processar usando o processo de QoS. As mensagens podem ter um sinalizador retido definido nelas. Se isso for definido, o broker MQTT armazenará a última mensagem enviada em um tópico com esse sinalizador e a enviará para qualquer cliente que assinar o tópico posteriormente. Dessa forma, os clientes sempre receberão a mensagem mais recente.
|
||||
|
||||
O MQTT também suporta uma função keep alive que verifica se a conexão ainda está ativa durante longos intervalos entre as mensagens.
|
||||
|
||||
> 🦟 [Mosquitto da Eclipse Foundation](https://mosquitto.org) tem um corretor MQTT gratuito que você pode executar para experimentar o MQTT, juntamente com um corretor MQTT público que você pode usar para testar seu código, hospedado em [test.mosquitto.org](https://test.mosquitto.org).
|
||||
|
||||
As conexões MQTT podem ser públicas e abertas ou criptografadas e protegidas usando nomes de usuário e senhas ou certificados.
|
||||
|
||||
> 💁 O MQTT se comunica por TCP/IP, o mesmo protocolo de rede subjacente do HTTP, mas em uma porta diferente. Você também pode usar o MQTT em websockets para se comunicar com aplicativos da Web executados em um navegador ou em situações em que firewalls ou outras regras de rede bloqueiam conexões MQTT padrão.
|
||||
|
||||
## Telemetria
|
||||
|
||||
A palavra telemetria é derivada das raízes gregas que significam medir remotamente. A telemetria é o ato de coletar dados de sensores e enviá-los para a nuvem.
|
||||
|
||||
> 💁 Um dos primeiros dispositivos de telemetria foi inventado na França em 1874 e enviava o clima em tempo real e as profundidades da neve do Mont Blanc a Paris. Ele usava fios físicos, pois as tecnologias sem fio não estavam disponíveis na época.
|
||||
|
||||
Vamos relembrar o exemplo do termostato inteligente da Lição 1.
|
||||
|
||||
|
||||
|
||||
O termostato possui sensores de temperatura para coletar telemetria. Ele provavelmente teria um sensor de temperatura embutido e poderia se conectar a vários sensores de temperatura externos por meio de um protocolo sem fio, como [Bluetooth Low Energy](https://wikipedia.org/wiki/Bluetooth_Low_Energy) (BLE).
|
||||
|
||||
Um exemplo dos dados de telemetria que enviaria poderia ser:
|
||||
|
||||
| Name | Value | Description |
|
||||
| ---- | ----- | ----------- |
|
||||
| `thermostat_temperature` | 18°C | A temperatura medida pelo sensor de temperatura embutido do termostato |
|
||||
| `livingroom_temperature` | 19°C | A temperatura medida por um sensor de temperatura remoto que foi chamado de "sala de estar" para identificar a sala em que está |
|
||||
| `bedroom_temperature` | 21°C | A temperatura medida por um sensor de temperatura remoto que foi chamado de "quarto" para identificar a sala em que está |
|
||||
|
||||
O serviço de nuvem pode então usar esses dados de telemetria para tomar decisões sobre quais comandos enviar para controlar o aquecimento.
|
||||
|
||||
### Envie telemetria do seu dispositivo IoT
|
||||
|
||||
A próxima parte da adição de controle de Internet à sua luz noturna é enviar a telemetria de nível de luz para o agente MQTT em um tópico de telemetria.
|
||||
|
||||
#### Tarefa - enviar telemetria do seu dispositivo IoT
|
||||
|
||||
Envie telemetria de nível leve para o broker MQTT.
|
||||
|
||||
Os dados são enviados codificados como JSON - abreviação de JavaScript Object Notation, um padrão para codificar dados em texto usando pares de chave/valor.
|
||||
|
||||
✅ Se você ainda não encontrou o JSON, saiba mais sobre ele na [documentação do JSON.org](https://www.json.org/).
|
||||
|
||||
Siga a etapa relevante abaixo para enviar a telemetria do seu dispositivo para o agente MQTT:
|
||||
|
||||
* [Arduino - Terminal Wio](wio-terminal-telemetry.md)
|
||||
* [Computador de placa única - dispositivo Raspberry Pi/Virtual IoT](single-board-computer-telemetry.md)
|
||||
|
||||
### Receber telemetria do broker MQTT
|
||||
|
||||
Não adianta enviar telemetria se não houver nada do outro lado para ouvi-la. A telemetria de nível de luz precisa de algo que a escute para processar os dados. Esse código 'servidor' é o tipo de código que você implantará em um serviço de nuvem como parte de um aplicativo IoT maior, mas aqui você executará esse código localmente no seu computador (ou no seu Pi, se estiver codificando diretamente lá ). O código do servidor consiste em um aplicativo Python que escuta mensagens de telemetria em MQTT com níveis leves. Mais adiante nesta lição, você fará com que ele responda com uma mensagem de comando com instruções para ligar ou desligar o LED.
|
||||
|
||||
✅ Faça alguma pesquisa: O que acontece com as mensagens MQTT se não houver um ouvinte?
|
||||
|
||||
#### Instale o Python e o VS Code
|
||||
|
||||
Se você não tiver o Python e o VS Code instalados localmente, precisará instalá-los para codificar o servidor. Se você estiver usando um dispositivo IoT virtual ou estiver trabalhando em seu Raspberry Pi, pule esta etapa, pois já deve tê-lo instalado e configurado.
|
||||
|
||||
##### Tarefa - instale o Python e o VS Code
|
||||
|
||||
Instale o Python e o VS Code.
|
||||
|
||||
1. Instale o Python. Consulte a [página de downloads do Python](https://www.python.org/downloads/) para obter instruções sobre como instalar a versão mais recente do Python.
|
||||
|
||||
1. Instale o Visual Studio Code (VS Code). Este é o editor que você usará para escrever o código do seu dispositivo virtual em Python. Consulte a [documentação do VS Code](https://code.visualstudio.com?WT.mc_id=academic-17441-jabenn) para obter instruções sobre como instalar o VS Code.
|
||||
|
||||
> 💁 Você pode usar qualquer IDE ou editor Python para essas lições se tiver uma ferramenta preferida, mas as lições fornecerão instruções baseadas no uso do VS Code.
|
||||
|
||||
1. Instale a extensão VS Code Pylance. Esta é uma extensão para o VS Code que fornece suporte à linguagem Python. Consulte a [documentação da extensão Pylance](https://marketplace.visualstudio.com/items?WT.mc_id=academic-17441-jabenn&itemName=ms-python.vscode-pylance) para obter instruções sobre como instalar essa extensão no VS Code.
|
||||
|
||||
#### Configurar um ambiente virtual Python
|
||||
|
||||
Um dos recursos poderosos do Python é a capacidade de instalar [pacotes pip](https://pypi.org) - são pacotes de código escritos por outras pessoas e publicados na Internet. Você pode instalar um pacote pip em seu computador com um comando e usar esse pacote em seu código. Você usará o pip para instalar um pacote para se comunicar pelo MQTT.
|
||||
|
||||
Por padrão, quando você instala um pacote, ele fica disponível em todos os lugares do seu computador, e isso pode levar a problemas com as versões do pacote - como um aplicativo dependendo de uma versão de um pacote que quebra quando você instala uma nova versão para um aplicativo diferente. Para contornar esse problema, você pode usar um [ambiente virtual Python](https://docs.python.org/3/library/venv.html), essencialmente uma cópia do Python em uma pasta dedicada, e quando você instala o pip pacotes eles são instalados apenas para essa pasta.
|
||||
|
||||
##### Tarefa - configurar um ambiente virtual Python
|
||||
|
||||
Configure um ambiente virtual Python e instale os pacotes pip MQTT.
|
||||
|
||||
1. Em seu terminal ou linha de comando, execute o seguinte em um local de sua escolha para criar e navegar para um novo diretório:
|
||||
|
||||
```sh
|
||||
mkdir nightlight-server
|
||||
cd nightlight-server
|
||||
```
|
||||
|
||||
1. Agora execute o seguinte para criar um ambiente virtual na pasta `.venv`
|
||||
|
||||
```sh
|
||||
python3 -m venv .venv
|
||||
```
|
||||
|
||||
> 💁 Você precisa chamar explicitamente `python3` para criar o ambiente virtual caso você tenha o Python 2 instalado além do Python 3 (a versão mais recente). Se você tiver o Python2 instalado, chamar `python` usará o Python 2 em vez do Python 3
|
||||
|
||||
1. Ative o ambiente virtual:
|
||||
|
||||
* No Windows:
|
||||
* Se você estiver usando o Prompt de Comando ou o Prompt de Comando pelo Terminal do Windows, execute:
|
||||
|
||||
```cmd
|
||||
.venv\Scripts\activate.bat
|
||||
```
|
||||
|
||||
* Se você estiver usando o PowerShell, execute:
|
||||
|
||||
```powershell
|
||||
.\.venv\Scripts\Activate.ps1
|
||||
```
|
||||
|
||||
* No macOS ou Linux, execute:
|
||||
|
||||
```cmd
|
||||
source ./.venv/bin/activate
|
||||
```
|
||||
|
||||
> 💁 Esses comandos devem ser executados no mesmo local em que você executou o comando para criar o ambiente virtual. Você nunca precisará navegar na pasta `.venv`, você deve sempre executar o comando activate e quaisquer comandos para instalar pacotes ou executar o código da pasta em que você estava quando criou o ambiente virtual.
|
||||
|
||||
1. Assim que o ambiente virtual for ativado, o comando padrão `python` executará a versão do Python que foi usada para criar o ambiente virtual. Execute o seguinte para obter a versão:
|
||||
|
||||
```sh
|
||||
python --version
|
||||
```
|
||||
|
||||
A saída será semelhante à seguinte:
|
||||
|
||||
```output
|
||||
(.venv) ➜ nightlight-server python --version
|
||||
Python 3.9.1
|
||||
```
|
||||
|
||||
> 💁 Sua versão do Python pode ser diferente - contanto que seja a versão 3.6 ou superior, você é bom. Caso contrário, exclua esta pasta, instale uma versão mais recente do Python e tente novamente.
|
||||
|
||||
1. Execute os comandos a seguir para instalar o pacote pip para [Paho-MQTT](https://pypi.org/project/paho-mqtt/), uma biblioteca MQTT popular.
|
||||
|
||||
```sh
|
||||
pip install paho-mqtt
|
||||
```
|
||||
|
||||
Este pacote pip será instalado apenas no ambiente virtual e não estará disponível fora dele.
|
||||
|
||||
#### Escreva o código do servidor
|
||||
|
||||
O código do servidor agora pode ser escrito em Python.
|
||||
|
||||
##### Tarefa - escreva o código do servidor
|
||||
|
||||
Escreva o código do servidor.
|
||||
|
||||
1. Em seu terminal ou linha de comando, execute o seguinte dentro do ambiente virtual para criar um arquivo Python chamado `app.py`:
|
||||
|
||||
* No Windows, execute:
|
||||
|
||||
```cmd
|
||||
type nul > app.py
|
||||
```
|
||||
|
||||
* No macOS ou Linux, execute:
|
||||
|
||||
```cmd
|
||||
touch app.py
|
||||
```
|
||||
|
||||
1. Abra a pasta atual no VS Code:
|
||||
|
||||
```sh
|
||||
code .
|
||||
```
|
||||
|
||||
1. Quando o VS Code for iniciado, ele ativará o ambiente virtual do Python. Isso será relatado na barra de status inferior:
|
||||
|
||||
|
||||
|
||||
1. Se o VS Code Terminal já estiver em execução quando o VS Code for inicializado, ele não terá o ambiente virtual ativado nele. A coisa mais fácil de fazer é matar o terminal usando o botão **Kill the active terminal instance**:
|
||||
|
||||
|
||||
|
||||
1. Inicie um novo Terminal VS Code selecionando *Terminal -> New Terminal, ou pressionando `` CTRL+` ``. O novo terminal carregará o ambiente virtual, com a chamada para ativá-lo aparecendo no terminal. O nome do ambiente virtual (`.venv`) também estará no prompt:
|
||||
|
||||
```output
|
||||
➜ nightlight-server source .venv/bin/activate
|
||||
(.venv) ➜ nightlight
|
||||
```
|
||||
|
||||
1. Abra o arquivo `app.py` no explorador do VS Code e adicione o seguinte código:
|
||||
|
||||
```python
|
||||
import json
|
||||
import time
|
||||
|
||||
import paho.mqtt.client as mqtt
|
||||
|
||||
id = '<ID>'
|
||||
|
||||
client_telemetry_topic = id + '/telemetry'
|
||||
client_name = id + 'nightlight_server'
|
||||
|
||||
mqtt_client = mqtt.Client(client_name)
|
||||
mqtt_client.connect('test.mosquitto.org')
|
||||
|
||||
mqtt_client.loop_start()
|
||||
|
||||
def handle_telemetry(client, userdata, message):
|
||||
payload = json.loads(message.payload.decode())
|
||||
print("Message received:", payload)
|
||||
|
||||
mqtt_client.subscribe(client_telemetry_topic)
|
||||
mqtt_client.on_message = handle_telemetry
|
||||
|
||||
while True:
|
||||
time.sleep(2)
|
||||
```
|
||||
|
||||
Substitua `<ID>` na linha 6 pelo ID exclusivo que você usou ao criar o código do seu dispositivo.
|
||||
|
||||
⚠️ Este **deve** ser o mesmo ID que você usou em seu dispositivo, ou o código do servidor não será inscrito ou publicado no tópico correto.
|
||||
|
||||
Esse código cria um cliente MQTT com um nome exclusivo e se conecta ao broker *test.mosquitto.org*. Em seguida, ele inicia um loop de processamento que é executado em um thread em segundo plano, ouvindo mensagens em qualquer tópico inscrito.
|
||||
|
||||
O cliente então assina mensagens no tópico de telemetria e define uma função que é chamada quando uma mensagem é recebida. Quando uma mensagem de telemetria é recebida, a função `handle_telemetry` é chamada, imprimindo a mensagem recebida no console.
|
||||
|
||||
Finalmente, um loop infinito mantém o aplicativo em execução. O cliente MQTT está ouvindo mensagens em um encadeamento em segundo plano e é executado o tempo todo em que o aplicativo principal está em execução.
|
||||
|
||||
1. No terminal do VS Code, execute o seguinte para executar seu aplicativo Python:
|
||||
|
||||
```sh
|
||||
python app.py
|
||||
```
|
||||
|
||||
O aplicativo começará a ouvir as mensagens do dispositivo IoT.
|
||||
|
||||
1. Certifique-se de que seu dispositivo esteja funcionando e enviando mensagens de telemetria. Ajuste os níveis de luz detectados pelo seu dispositivo físico ou virtual. As mensagens recebidas serão impressas no terminal.
|
||||
|
||||
```output
|
||||
(.venv) ➜ nightlight-server python app.py
|
||||
Message received: {'light': 0}
|
||||
Message received: {'light': 400}
|
||||
```
|
||||
|
||||
O arquivo app.py no ambiente virtual nightlight deve estar em execução para que o arquivo app.py no ambiente virtual nightlight-server receba as mensagens que estão sendo enviadas.
|
||||
|
||||
> 💁 Você pode encontrar este código na pasta [code-server/server](../code-server/server).
|
||||
|
||||
### Com que frequência a telemetria deve ser enviada?
|
||||
|
||||
Uma consideração importante com a telemetria é com que frequência medir e enviar os dados? A resposta é - depende. Se você mede com frequência, pode responder mais rapidamente às mudanças nas medições, mas usa mais energia, mais largura de banda, gera mais dados e precisa de mais recursos de nuvem para processar. Você precisa medir com frequência suficiente, mas não com muita frequência.
|
||||
|
||||
Para um termostato, medir a cada poucos minutos provavelmente é mais do que suficiente, pois as temperaturas não mudam com tanta frequência. Se você medir apenas uma vez por dia, poderá acabar aquecendo sua casa para temperaturas noturnas no meio de um dia ensolarado, enquanto se medir a cada segundo, terá milhares de medições de temperatura duplicadas desnecessariamente que consumirão a velocidade da Internet dos usuários e largura de banda (um problema para pessoas com planos de largura de banda limitados), usar mais energia, o que pode ser um problema para dispositivos alimentados por bateria, como sensores remotos, e aumentar o custo dos recursos de computação em nuvem dos provedores que os processam e armazenam.
|
||||
|
||||
Se você estiver monitorando dados em torno de uma máquina em uma fábrica que, se falhar, pode causar danos catastróficos e milhões de dólares em receita perdida, pode ser necessário medir várias vezes por segundo. É melhor desperdiçar largura de banda do que perder a telemetria que indica que uma máquina precisa ser parada e consertada antes de quebrar.
|
||||
|
||||
> 💁 Nessa situação, você pode considerar ter um dispositivo de borda para processar a telemetria primeiro para reduzir a dependência da Internet.
|
||||
|
||||
### Perda de conectividade
|
||||
|
||||
As conexões com a Internet podem não ser confiáveis, com interrupções comuns. O que um dispositivo IoT deve fazer nessas circunstâncias - ele deve perder os dados ou deve armazená-los até que a conectividade seja restaurada? Novamente, a resposta é depende.
|
||||
|
||||
Para um termostato, os dados provavelmente podem ser perdidos assim que uma nova medição de temperatura for feita. O sistema de aquecimento não se importa que 20 minutos atrás era 20,5°C se a temperatura agora é 19°C, é a temperatura agora que determina se o aquecimento deve ser ligado ou desligado.
|
||||
|
||||
Para máquinas, você pode querer manter os dados, especialmente se for usado para procurar tendências. Existem modelos de aprendizado de máquina que podem detectar anomalias em fluxos de dados examinando dados de um período de tempo definido (como a última hora) e identificando dados anômalos. Isso geralmente é usado para manutenção preditiva, procurando indicações de que algo pode quebrar em breve para que você possa repará-lo ou substituí-lo antes que isso aconteça. Você pode querer que cada bit de telemetria de uma máquina seja enviado para que possa ser processado para detecção de anomalias, portanto, assim que o dispositivo IoT puder se reconectar, ele enviará toda a telemetria gerada durante a interrupção da Internet.
|
||||
|
||||
Os designers de dispositivos IoT também devem considerar se o dispositivo IoT pode ser usado durante uma interrupção na Internet ou perda de sinal causada pela localização. Um termostato inteligente deve ser capaz de tomar algumas decisões limitadas para controlar o aquecimento se não puder enviar telemetria para a nuvem devido a uma interrupção.
|
||||
|
||||
[](https://twitter.com/internetofshit/status/1315736960082808832)
|
||||
|
||||
Para que o MQTT lide com uma perda de conectividade, o código do dispositivo e do servidor precisará ser responsável por garantir a entrega da mensagem, se necessário, por exemplo, exigindo que todas as mensagens enviadas sejam respondidas por mensagens adicionais em um tópico de resposta e, se não eles são enfileirados manualmente para serem reproduzidos posteriormente.
|
||||
|
||||
## Commands
|
||||
|
||||
Comandos são mensagens enviadas pela nuvem para um dispositivo, instruindo-o a fazer algo. Na maioria das vezes, isso envolve fornecer algum tipo de saída por meio de um atuador, mas pode ser uma instrução para o próprio dispositivo, como reinicializar ou reunir telemetria extra e devolvê-la como resposta ao comando.
|
||||
|
||||
|
||||
|
||||
Um termostato poderia receber um comando da nuvem para ligar o aquecimento. Com base nos dados de telemetria de todos os sensores, se o serviço de nuvem decidiu que o aquecimento deve estar ligado, ele envia o comando relevante.
|
||||
|
||||
### Envie comandos para o broker MQTT
|
||||
|
||||
O próximo passo para nossa luz noturna controlada pela Internet é que o código do servidor envie um comando de volta ao dispositivo IoT para controlar a luz com base nos níveis de luz detectados.
|
||||
|
||||
1. Abra o código do servidor no VS Code
|
||||
|
||||
1. Adicione a seguinte linha após a declaração do `client_telemetry_topic` para definir para qual tópico enviar comandos:
|
||||
|
||||
```python
|
||||
server_command_topic = id + '/commands'
|
||||
```
|
||||
|
||||
1. Adicione o seguinte código ao final da função `handle_telemetry`:
|
||||
|
||||
```python
|
||||
command = { 'led_on' : payload['light'] < 300 }
|
||||
print("Sending message:", command)
|
||||
|
||||
client.publish(server_command_topic, json.dumps(command))
|
||||
```
|
||||
|
||||
Isso envia uma mensagem JSON para o tópico de comando com o valor de `led_on` definido como verdadeiro ou falso, dependendo se a luz for menor que 300 ou não. Se a luz for menor que 300, true é enviado para instruir o dispositivo a ligar o LED.
|
||||
|
||||
1. Execute o código como antes
|
||||
|
||||
1. Ajuste os níveis de luz detectados pelo seu dispositivo físico ou virtual. As mensagens recebidas e os comandos enviados serão gravados no terminal:
|
||||
|
||||
```output
|
||||
(.venv) ➜ nightlight-server python app.py
|
||||
Message received: {'light': 0}
|
||||
Sending message: {'led_on': True}
|
||||
Message received: {'light': 400}
|
||||
Sending message: {'led_on': False}
|
||||
```
|
||||
|
||||
> 💁 A telemetria e os comandos estão sendo enviados em um único tópico cada. Isso significa que a telemetria de vários dispositivos aparecerá no mesmo tópico de telemetria e os comandos para vários dispositivos aparecerão no mesmo tópico de comandos. Se você quiser enviar um comando para um dispositivo específico, poderá usar vários tópicos, nomeados com um ID de dispositivo exclusivo, como `/commands/device1`, `/commands/device2`. Dessa forma, um dispositivo pode ouvir mensagens destinadas apenas a esse dispositivo.
|
||||
|
||||
> 💁 Você pode encontrar este código na pasta [code-commands/server](code-commands/server).
|
||||
|
||||
### Manipular comandos no dispositivo IoT
|
||||
|
||||
Agora que os comandos estão sendo enviados do servidor, você pode adicionar código ao dispositivo IoT para lidar com eles e controlar o LED.
|
||||
|
||||
Siga a etapa relevante abaixo para ouvir os comandos do broker MQTT:
|
||||
|
||||
* [Arduino - Terminal Wio](wio-terminal-commands.md)
|
||||
* [Computador de placa única - dispositivo Raspberry Pi/Virtual IoT](single-board-computer-commands.md)
|
||||
|
||||
Depois que esse código estiver escrito e em execução, experimente alterar os níveis de luz. Observe a saída do servidor e do dispositivo e observe o LED conforme você altera os níveis de luz.
|
||||
|
||||
### Perda de conectividade
|
||||
|
||||
O que um serviço de nuvem deve fazer se precisar enviar um comando para um dispositivo IoT que está offline? Novamente, a resposta é depende.
|
||||
|
||||
Se o comando mais recente substituir um anterior, os anteriores provavelmente poderão ser ignorados. Se um serviço de nuvem envia um comando para ligar o aquecimento e, em seguida, envia um comando para desligá-lo, o comando de ligar pode ser ignorado e não reenviado.
|
||||
|
||||
Se os comandos precisarem ser processados em sequência, como mover um braço do robô para cima e fechar um grabber, eles precisam ser enviados em ordem assim que a conectividade for restaurada.
|
||||
|
||||
✅ Como o código do dispositivo ou do servidor pode garantir que os comandos sejam sempre enviados e manipulados em ordem no MQTT, se necessário?
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Desafio
|
||||
|
||||
O desafio nas últimas três lições foi listar o maior número possível de dispositivos IoT que estão em sua casa, escola ou local de trabalho e decidir se eles são construídos em torno de microcontroladores ou computadores de placa única, ou mesmo uma mistura de ambos, e pensar sobre quais sensores e atuadores eles estão usando.
|
||||
|
||||
Para esses dispositivos, pense em quais mensagens eles podem estar enviando ou recebendo. Que telemetria eles enviam? Que mensagens ou comandos eles podem receber? Você acha que eles são seguros?
|
||||
|
||||
## Questionário pós-aula
|
||||
|
||||
[Quiz pós-aula](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/8)
|
||||
|
||||
## Revisão e autoestudo
|
||||
|
||||
Leia mais sobre MQTT na [página MQTT Wikipedia](https://wikipedia.org/wiki/MQTT).
|
||||
|
||||
Tente executar você mesmo um broker MQTT usando [Mosquitto](https://www.mosquitto.org) e conecte-se a ele a partir de seu dispositivo IoT e código do servidor.
|
||||
|
||||
> 💁 Dica - por padrão, o Mosquitto não permite conexões anônimas (ou seja, conexão sem nome de usuário e senha), e não permite conexões de fora do computador em que está sendo executado.
|
||||
> Você pode corrigir isso com um [arquivo de configuração `mosquitto.conf`](https://www.mosquitto.org/man/mosquitto-conf-5.html) com o seguinte:
|
||||
>
|
||||
> ```sh
|
||||
> listener 1883 0.0.0.0
|
||||
> allow_anonymous true
|
||||
> ```
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Compare e contraste o MQTT com outros protocolos de comunicação](assignment.pt.md)
|
||||
@ -0,0 +1,14 @@
|
||||
# Comparar e contrastar o MQTT com outros protocolos de comunicação
|
||||
|
||||
## Instruções
|
||||
|
||||
Esta lição abordou o MQTT como protocolos de comunicação. Existem outros, incluindo AMQP e HTTP/HTTPS.
|
||||
|
||||
Pesquise ambos e compare/contrate-os com o MQTT. Pense no uso de energia, segurança e persistência de mensagens se as conexões forem perdidas.
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Precisa de Melhoria |
|
||||
| -------- | --------- | -------- | ----------------- |
|
||||
| Comparar AMQP com MQTT | É capaz de comparar e contrastar AMQP com MQTT e abrange energia, segurança e persistência de mensagens. | É parcialmente capaz de comparar e contrastar AMQP com MQTT e abrange dois aspectos de energia, segurança e persistência de mensagens. | É parcialmente capaz de comparar e contrastar AMQP com MQTT e abrange energia, segurança e persistência de mensagens. |
|
||||
| Comparar HTTP/HTTPS com MQTT | É capaz de comparar e contrastar HTTP/HTTPS com MQTT e abrange energia, segurança e persistência de mensagens. | É parcialmente capaz de comparar e contrastar HTTP/HTTPS com MQTT e abrange dois aspectos de energia, segurança e persistência de mensagens. | É parcialmente capaz de comparar e contrastar HTTP/HTTPS com MQTT e abrange energia, segurança e persistência de mensagens. |
|
||||
@ -0,0 +1,43 @@
|
||||
# Visualize dados GDD usando um Jupyter Notebook
|
||||
|
||||
## Instruções
|
||||
|
||||
Nesta lição, você coletou dados do GDD usando um sensor de IoT. Para obter bons dados do GDD, você precisa coletar dados por vários dias. Para ajudar a visualizar os dados de temperatura e calcular o GDD, você pode usar ferramentas como [Jupyter Notebooks](https://jupyter.org) para analisar os dados.
|
||||
|
||||
Comece coletando dados por alguns dias. Você precisará garantir que seu código de servidor esteja em execução o tempo todo em que seu dispositivo IoT estiver em execução, ajustando suas configurações de gerenciamento de energia ou executando algo como [este script em python para manter o sistema ativo](https://github.com/jaqsparow/keep-system-active).
|
||||
|
||||
Depois de ter os dados de temperatura, você pode usar o Jupyter Notebook neste repositório para visualizá-los e calcular o GDD. Os notebooks Jupyter misturam código e instruções em blocos chamados *cells*, geralmente código em Python. Você pode ler as instruções e executar cada bloco de código, bloco por bloco. Você também pode editar o código. Neste notebook, por exemplo, você pode editar a temperatura base usada para calcular o GDD para sua planta.
|
||||
|
||||
1. Crie uma pasta chamada `gdd-calculation`
|
||||
|
||||
1. Baixe o arquivo [gdd.ipynb](./../code-notebook/gdd.ipynb) e copie-o para a pasta `gdd-calculation`.
|
||||
|
||||
1. Copie o arquivo `temperature.csv` criado pelo servidor MQTT
|
||||
|
||||
1. Crie um novo ambiente virtual Python na pasta `gdd-calculation`.
|
||||
|
||||
1. Instale alguns pacotes pip para notebooks Jupyter, juntamente com as bibliotecas necessárias para gerenciar e plotar os dados:
|
||||
|
||||
```sh
|
||||
pip install --upgrade pip
|
||||
pip install pandas
|
||||
pip install matplotlib
|
||||
pip install jupyter
|
||||
```
|
||||
|
||||
1. Execute o notebook no Jupyter:
|
||||
|
||||
```sh
|
||||
jupyter notebook gdd.ipynb
|
||||
```
|
||||
|
||||
O Jupyter iniciará e abrirá o notebook em seu navegador. Trabalhe com as instruções no notebook para visualizar as temperaturas medidas e calcular os graus-dia crescentes.
|
||||
|
||||
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Criteria | Exemplary | Adequate | Needs Improvement |
|
||||
| -------- | --------- | -------- | ----------------- |
|
||||
| Capture dados | Capture ao menos 2 dias completos de dados | Capture ao menos 1 dia completo de dados | Capture algum dado |
|
||||
| Calcule o GDD | Execute o notebook com sucesso e calcule o GDD | Execute o notebook com sucesso | Não consigo executar o notebook |
|
||||
@ -0,0 +1,111 @@
|
||||
# Medir a temperatura - Raspberry Pi
|
||||
|
||||
Nesta parte da lição, você adicionará um sensor de temperatura ao seu Raspberry Pi.
|
||||
|
||||
## Hardware
|
||||
|
||||
O sensor que você usará é um [sensor de umidade e temperatura DHT11](https://www.seeedstudio.com/Grove-Temperature-Humidity-Sensor-DHT11.html), combinando 2 sensores em um pacote. Isso é bastante popular, com vários sensores comercialmente disponíveis combinando temperatura, umidade e, às vezes, pressão atmosférica. O componente do sensor de temperatura é um termistor de coeficiente de temperatura negativo (NTC), um termistor onde a resistência diminui à medida que a temperatura aumenta.
|
||||
|
||||
This is a digital sensor, so has an onboard ADC to create a digital signal containing the temperature and humidity data that the microcontroller can read.
|
||||
|
||||
### Conecte o sensor de temperatura
|
||||
|
||||
O sensor de temperatura Grove pode ser conectado ao Raspberry Pi.
|
||||
|
||||
#### Tarefa
|
||||
|
||||
Conecte o sensor de temperatura
|
||||
|
||||
|
||||
|
||||
1. Insira uma extremidade de um cabo Grove no soquete do sensor de umidade e temperatura. Só vai dar uma volta.
|
||||
|
||||
1. Com o Raspberry Pi desligado, conecte a outra extremidade do cabo Grove ao soquete digital marcado como **D5** no chapéu Grove Base conectado ao Pi. Este soquete é o segundo da esquerda, na fileira de soquetes ao lado dos pinos GPIO.
|
||||
|
||||
|
||||
|
||||
## Programe o sensor de temperatura
|
||||
|
||||
O dispositivo agora pode ser programado para usar o sensor de temperatura conectado.
|
||||
|
||||
### Tarefa
|
||||
|
||||
Programe o dispositivo.
|
||||
|
||||
1. Ligue o Pi e espere que ele inicialize
|
||||
|
||||
1. Inicie o VS Code, diretamente no Pi ou conecte-se através da extensão SSH remota.
|
||||
|
||||
> ⚠️ Você pode consultar [as instruções para configurar e iniciar o VS Code na lição 1, se necessário](../../../../1-getting-started/lessons/1-introduction-to-iot/translations/pi.pt.md).
|
||||
|
||||
1. A partir do terminal, crie uma nova pasta no diretório inicial dos usuários `pi` chamada `temperature-sensor`. Crie um arquivo nesta pasta chamado `app.py`:
|
||||
|
||||
```sh
|
||||
mkdir temperature-sensor
|
||||
cd temperature-sensor
|
||||
touch app.py
|
||||
```
|
||||
|
||||
1. Abra esta pasta no VS Code
|
||||
|
||||
1. Para usar o sensor de temperatura e umidade, um pacote Pip adicional precisa ser instalado. No Terminal no VS Code, execute o seguinte comando para instalar este pacote Pip no Pi:
|
||||
|
||||
```sh
|
||||
pip3 install seeed-python-dht
|
||||
```
|
||||
|
||||
1. Adicione o seguinte código ao arquivo `app.py` para importar as bibliotecas necessárias:
|
||||
|
||||
```python
|
||||
import time
|
||||
from seeed_dht import DHT
|
||||
```
|
||||
|
||||
A instrução `from seeed_dht import DHT` importa a classe de sensor `DHT` para interagir com um sensor de temperatura Grove do módulo `seeed_dht`.
|
||||
|
||||
1. Adicione o seguinte código após o código acima para criar uma instância da classe que gerencia o sensor de temperatura:
|
||||
|
||||
```python
|
||||
sensor = DHT("11", 5)
|
||||
```
|
||||
|
||||
Isso declara uma instância da classe `DHT` que gerencia o sensor de **D**igital **H**umidade e **T** de temperatura. O primeiro parâmetro informa ao código que o sensor que está sendo usado é o sensor *DHT11* - a biblioteca que você está usando suporta outras variantes desse sensor. O segundo parâmetro informa ao código que o sensor está conectado à porta digital `D5` no chapéu base Grove.
|
||||
|
||||
> ✅ Lembre-se, todos os soquetes têm números de pinos exclusivos. Os pinos 0, 2, 4 e 6 são pinos analógicos, pinos 5, 16, 18, 22, 24 e 26 são pinos digitais.
|
||||
|
||||
1. Adicione um loop infinito após o código acima para pesquisar o valor do sensor de temperatura e imprimi-lo no console:
|
||||
|
||||
```python
|
||||
while True:
|
||||
_, temp = sensor.read()
|
||||
print(f'Temperature {temp}°C')
|
||||
```
|
||||
|
||||
A chamada para `sensor.read()` retorna uma tupla de umidade e temperatura. Você só precisa do valor da temperatura, então a umidade é ignorada. O valor da temperatura é então impresso no console.
|
||||
|
||||
1. Adicione um pequeno descanso de dez segundos no final do 'loop', pois os níveis de temperatura não precisam ser verificados continuamente. Uma suspensão reduz o consumo de energia do dispositivo.
|
||||
|
||||
```python
|
||||
time.sleep(10)
|
||||
```
|
||||
|
||||
1. No Terminal do VS Code, execute o seguinte para executar seu aplicativo Python:
|
||||
|
||||
```sh
|
||||
python3 app.py
|
||||
```
|
||||
|
||||
Você deve ver os valores de temperatura sendo emitidos para o console. Use algo para aquecer o sensor, como pressionar o polegar sobre ele ou usar um ventilador para ver os valores mudarem:
|
||||
|
||||
```output
|
||||
pi@raspberrypi:~/temperature-sensor $ python3 app.py
|
||||
Temperature 26°C
|
||||
Temperature 26°C
|
||||
Temperature 28°C
|
||||
Temperature 30°C
|
||||
Temperature 32°C
|
||||
```
|
||||
|
||||
> 💁 Você pode encontrar esse código na pasta [code-temperature/pi](../code-temperature/pi).
|
||||
|
||||
😀 Seu programa de sensor de temperatura foi um sucesso!
|
||||
@ -0,0 +1,57 @@
|
||||
# Temperatura de publicação - Virtual IoT Hardware e Raspberry Pi
|
||||
|
||||
Nesta parte da lição, você publicará os valores de temperatura detectados pelo Raspberry Pi ou Virtual IoT Device sobre MQTT para que possam ser usados posteriormente para calcular o GDD.
|
||||
|
||||
## Publica a temperatura
|
||||
|
||||
Uma vez que a temperatura tenha sido lida, ela pode ser publicada no MQTT para algum código 'servidor' que lerá os valores e os armazenará prontos para serem usados para um cálculo de GDD.
|
||||
|
||||
### Tarefa - publicar a temperatura
|
||||
|
||||
Programe o dispositivo para publicar os dados de temperatura.
|
||||
|
||||
1. Abra o projeto do aplicativo `temperature-sensor` se ainda não estiver aberto
|
||||
|
||||
1. Repita as etapas que você fez na lição 4 para se conectar ao MQTT e enviar a telemetria. Você estará usando o mesmo broker público do Mosquitto.
|
||||
|
||||
Os passos para isso são:
|
||||
|
||||
- Adicione o pacote pip MQTT
|
||||
- Adicione o código para se conectar ao broker MQTT
|
||||
- Adicione o código para publicar a telemetria
|
||||
|
||||
> ⚠️ Consulte as [instruções para conectar-se ao MQTT](../../../1-getting-started/lessons/4-connect-internet/single-board-computer-mqtt.md) e as [instruções para enviar telemetry](../../../1-getting-started/lessons/4-connect-internet/single-board-computer-telemetry.md) da lição 4, se necessário.
|
||||
|
||||
1. Certifique-se de que o `client_name` reflita este nome de projeto:
|
||||
|
||||
```python
|
||||
client_name = id + 'temperature_sensor_client'
|
||||
```
|
||||
|
||||
1. Para a telemetria, em vez de enviar um valor de luz, envie o valor de temperatura lido do sensor DHT em uma propriedade no documento JSON chamada `temperature`:
|
||||
|
||||
```python
|
||||
_, temp = sensor.read()
|
||||
telemetry = json.dumps({'temperature' : temp})
|
||||
```
|
||||
|
||||
1. O valor da temperatura não precisa ser lido com muita frequência - não mudará muito em um curto espaço de tempo, então defina o `time.sleep` para 10 minutos:
|
||||
|
||||
```cpp
|
||||
time.sleep(10 * 60);
|
||||
```
|
||||
|
||||
> 💁 A função `sleep` leva o tempo em segundos, então para facilitar a leitura o valor é passado como resultado de um cálculo. 60s em um minuto, então 10x (60s em um minuto) dá um atraso de 10 minutos.
|
||||
|
||||
1. Execute o código da mesma forma que você executou o código da parte anterior da atribuição. Se você estiver usando um dispositivo IoT virtual, verifique se o aplicativo CounterFit está em execução e se os sensores de umidade e temperatura foram criados nos pinos corretos.
|
||||
|
||||
```output
|
||||
pi@raspberrypi:~/temperature-sensor $ python3 app.py
|
||||
MQTT connected!
|
||||
Sending telemetry {"temperature": 25}
|
||||
Sending telemetry {"temperature": 25}
|
||||
```
|
||||
|
||||
> 💁 Você pode encontrar esse código na pasta [code-publish-temperature/virtual-device](code-publish-temperature/virtual-device) ou na pasta [code-publish-temperature/pi](code-publish-temperature/pi).
|
||||
|
||||
😀 Você publicou com sucesso a temperatura como telemetria do seu dispositivo.
|
||||
@ -0,0 +1,140 @@
|
||||
# Medir a temperatura - Hardware de IoT virtual
|
||||
|
||||
Nesta parte da lição, você adicionará um sensor de temperatura ao seu dispositivo IoT virtual.
|
||||
|
||||
## Hardware Virtual
|
||||
|
||||
O dispositivo IoT virtual usará um sensor de umidade e temperatura digital Grove simulado. Isso mantém este laboratório igual ao uso de um Raspberry Pi com um sensor físico Grove DHT11.
|
||||
|
||||
O sensor combina um **sensor de temperatura** com um **sensor de umidade**, mas neste laboratório você está interessado apenas no componente do sensor de temperatura. Em um dispositivo IoT físico, o sensor de temperatura seria um [termistor](https://wikipedia.org/wiki/Thermistor) que mede a temperatura detectando uma mudança na resistência à medida que a temperatura muda. Os sensores de temperatura geralmente são sensores digitais que convertem internamente a resistência medida em uma temperatura em graus Celsius (ou Kelvin ou Fahrenheit).
|
||||
|
||||
### Adicione os sensores ao CounterFit
|
||||
|
||||
Para usar um sensor virtual de umidade e temperatura, você precisa adicionar os dois sensores ao aplicativo CounterFit
|
||||
|
||||
#### Tarefa - adicione os sensores ao CounterFit
|
||||
|
||||
Adicione os sensores de umidade e temperatura ao aplicativo CounterFit.
|
||||
|
||||
1. Crie um novo aplicativo Python em seu computador em uma pasta chamada `temperature-sensor` com um único arquivo chamado `app.py` e um ambiente virtual Python, e adicione os pacotes pip CounterFit.
|
||||
|
||||
> ⚠️ Você pode consultar [as instruções para criar e configurar um projeto CounterFit Python na lição 1, se necessário](../../../../1-getting-started/lessons/1-introduction-to-iot/translations/virtual-device.pt.md).
|
||||
|
||||
1. Instale um pacote Pip adicional para instalar um calço CounterFit para o sensor DHT11. Certifique-se de estar instalando isso de um terminal com o ambiente virtual ativado.
|
||||
|
||||
```sh
|
||||
pip install counterfit-shims-seeed-python-dht
|
||||
```
|
||||
|
||||
1. Verifique se o aplicativo da web CounterFit está em execução
|
||||
|
||||
1. Crie um sensor de umidade:
|
||||
|
||||
1. Na caixa *Criar sensor* no painel *Sensores*, abra a caixa *Tipo de sensor* e selecione *Umidade*.
|
||||
|
||||
1. Deixe as *Unidades* definidas como *Porcentagem*
|
||||
|
||||
1. Certifique-se de que o *Pino* esteja definido como *5*
|
||||
|
||||
1. Selecione o botão **Adicionar** para criar o sensor de umidade no pino 5
|
||||
|
||||
|
||||
|
||||
O sensor de umidade será criado e aparecerá na lista de sensores.
|
||||
|
||||
|
||||
|
||||
1. Crie um sensor de temperatura:
|
||||
|
||||
1. Na caixa *Criar sensor* no painel *Sensores*, abra a caixa *Tipo de sensor* e selecione *Temperatura*.
|
||||
|
||||
1. Deixe as *Unidades* definidas como *Celsius*
|
||||
|
||||
1. Verifique se o *Pin* está definido como *6*
|
||||
|
||||
1. Selecione o botão **Adicionar** para criar o sensor de temperatura no Pino 6
|
||||
|
||||
|
||||
|
||||
O sensor de temperatura será criado e aparecerá na lista de sensores.
|
||||
|
||||
|
||||
|
||||
## Programe o aplicativo do sensor de temperatura
|
||||
|
||||
O aplicativo do sensor de temperatura agora pode ser programado usando os sensores CounterFit.
|
||||
|
||||
### Tarefa - programar o aplicativo do sensor de temperatura
|
||||
|
||||
Programe o aplicativo do sensor de temperatura.
|
||||
|
||||
1. Verifique se o aplicativo `temperature-sensor` está aberto no VS Code
|
||||
|
||||
1. Abra o arquivo `app.py`
|
||||
|
||||
1. Adicione o seguinte código na parte superior de `app.py` para conectar o aplicativo ao CounterFit:
|
||||
|
||||
```python
|
||||
from counterfit_connection import CounterFitConnection
|
||||
CounterFitConnection.init('127.0.0.1', 5000)
|
||||
```
|
||||
|
||||
1. Adicione o seguinte código ao arquivo `app.py` para importar as bibliotecas necessárias:
|
||||
|
||||
```python
|
||||
import time
|
||||
from counterfit_shims_seeed_python_dht import DHT
|
||||
```
|
||||
|
||||
A instrução `from seeed_dht import DHT` importa a classe de sensor `DHT` para interagir com um sensor de temperatura Grove virtual usando um calço do módulo `counterfit_shims_seeed_python_dht`.
|
||||
|
||||
1. Adicione o seguinte código após o código acima para criar uma instância da classe que gerencia o sensor virtual de umidade e temperatura:
|
||||
|
||||
```python
|
||||
sensor = DHT("11", 5)
|
||||
```
|
||||
|
||||
Isso declara uma instância da classe `DHT` que gerencia o sensor virtual **D**igital **H** de umidade e **T** de temperatura. O primeiro parâmetro informa ao código que o sensor que está sendo usado é um sensor virtual *DHT11*. O segundo parâmetro informa ao código que o sensor está conectado à porta `5`.
|
||||
|
||||
> 💁 O CounterFit simula este sensor combinado de umidade e temperatura conectando-se a 2 sensores, um sensor de umidade no pino fornecido quando a classe `DHT` é criada e um sensor de temperatura que é executado no próximo pino. Se o sensor de umidade estiver no pino 5, o calço espera que o sensor de temperatura esteja no pino 6.
|
||||
|
||||
1. Adicione um loop infinito após o código acima para pesquisar o valor do sensor de temperatura e imprimi-lo no console:
|
||||
|
||||
```python
|
||||
while True:
|
||||
_, temp = sensor.read()
|
||||
print(f'Temperature {temp}°C')
|
||||
```
|
||||
|
||||
A chamada para `sensor.read()` retorna uma tupla de umidade e temperatura. Você só precisa do valor da temperatura, então a umidade é ignorada. O valor da temperatura é então impresso no console.
|
||||
|
||||
1. Adicione um pequeno descanso de dez segundos no final do 'loop', pois os níveis de temperatura não precisam ser verificados continuamente. Uma suspensão reduz o consumo de energia do dispositivo.
|
||||
|
||||
```python
|
||||
time.sleep(10)
|
||||
```
|
||||
|
||||
1. No Terminal do VS Code com um ambiente virtual ativado, execute o seguinte para executar seu aplicativo Python:
|
||||
|
||||
```sh
|
||||
python app.py
|
||||
```
|
||||
|
||||
1. A partir do aplicativo CounterFit, altere o valor do sensor de temperatura que será lido pelo aplicativo. Você pode fazer isso de duas maneiras:
|
||||
|
||||
* Insira um número na caixa *Value* para o sensor de temperatura e selecione o botão **Set**. O número que você inserir será o valor retornado pelo sensor.
|
||||
|
||||
* Marque a caixa de seleção *Random* e insira um valor *Min* e *Max* e selecione o botão **Set**. Cada vez que o sensor lê um valor, ele lê um número aleatório entre *Min* e *Max*.
|
||||
|
||||
Você deve ver os valores que definiu aparecendo no console. Altere as configurações de *Value* ou *Random* para ver a alteração do valor.
|
||||
|
||||
```output
|
||||
(.venv) ➜ temperature-sensor python app.py
|
||||
Temperature 28.25°C
|
||||
Temperature 30.71°C
|
||||
Temperature 25.17°C
|
||||
```
|
||||
|
||||
> 💁 Você pode encontrar esse código na pasta [code-temperature/virtual-device](../code-temperature/virtual-device).
|
||||
|
||||
😀 Seu programa de sensor de temperatura foi um sucesso!
|
||||
@ -0,0 +1,129 @@
|
||||
# Medir temperatura - Terminal Wio
|
||||
|
||||
Nesta parte da lição, você adicionará um sensor de temperatura ao seu Terminal Wio e lerá os valores de temperatura a partir dele.
|
||||
|
||||
## Hardware
|
||||
|
||||
O Terminal Wio precisa de um sensor de temperatura.
|
||||
|
||||
O sensor que você usará é um [sensor de umidade e temperatura DHT11](https://www.seeedstudio.com/Grove-Temperature-Humidity-Sensor-DHT11.html), combinando 2 sensores em um pacote. Isso é bastante popular, com vários sensores comercialmente disponíveis combinando temperatura, umidade e, às vezes, pressão atmosférica. O componente do sensor de temperatura é um termistor de coeficiente de temperatura negativo (NTC), um termistor onde a resistência diminui à medida que a temperatura aumenta.
|
||||
|
||||
Este é um sensor digital, portanto, possui um ADC integrado para criar um sinal digital contendo os dados de temperatura e umidade que o microcontrolador pode ler.
|
||||
|
||||
### Conecte o sensor de temperatura
|
||||
|
||||
O sensor de temperatura Grove pode ser conectado à porta digital Wio Terminals.
|
||||
|
||||
#### Tarefa - conecte o sensor de temperatura
|
||||
|
||||
Conecte o sensor de temperatura.
|
||||
|
||||
|
||||
|
||||
1. Insira uma extremidade de um cabo Grove no soquete do sensor de umidade e temperatura. Só vai dar uma volta.
|
||||
|
||||
1. Com o Terminal Wio desconectado do computador ou de outra fonte de alimentação, conecte a outra extremidade do cabo Grove ao soquete Grove do lado direito do Terminal Wio enquanto olha para a tela. Este é o soquete mais distante do botão liga/desliga.
|
||||
|
||||
|
||||
|
||||
## Programar o sensor de temperatura
|
||||
|
||||
O Terminal Wio agora pode ser programado para usar o sensor de temperatura conectado.
|
||||
|
||||
### Tarefa: programar o sensor de temperatura
|
||||
|
||||
Programe o dispositivo.
|
||||
|
||||
1. Crie um novo projeto de Terminal Wio usando PlatformIO. Chame este projeto de `sensor de temperatura`. Adicione código na função `setup` para configurar a porta serial.
|
||||
|
||||
> ⚠️ Você pode consultar [as instruções para criar um projeto PlatformIO no projeto 1, lição 1, se necessário](../../../1-getting-started/lessons/1-introduction-to-iot/translations/wio-terminal.pt.md#crie-um-projeto-platformio).
|
||||
|
||||
1. Adicione uma dependência de biblioteca para a biblioteca do sensor de umidade e temperatura Seeed Grove ao arquivo `platformio.ini` do projeto:
|
||||
|
||||
```ini
|
||||
lib_deps =
|
||||
seeed-studio/Grove Temperature And Humidity Sensor @ 1.0.1
|
||||
```
|
||||
|
||||
> ⚠️ Você pode consultar [as instruções para adicionar bibliotecas a um projeto PlatformIO no projeto 1, lição 4, se necessário](../../../../1-getting-started/lessons/4-connect-internet/translactions/wio-terminal-mqtt.pt.md#install-the-wifi-and-mqtt-arduino-libraries).
|
||||
|
||||
1. Adicione as seguintes diretivas `#include` ao topo do arquivo, sob o `#include <Arduino.h>` existente:
|
||||
|
||||
```cpp
|
||||
#include <DHT.h>
|
||||
#include <SPI.h>
|
||||
```
|
||||
|
||||
Isso importa os arquivos necessários para interagir com o sensor. O arquivo de cabeçalho `DHT.h` contém o código para o próprio sensor, e adicionar o cabeçalho `SPI.h` garante que o código necessário para se comunicar com o sensor seja vinculado quando o aplicativo for compilado.
|
||||
|
||||
1. Antes da função `setup`, declare o sensor DHT:
|
||||
|
||||
```cpp
|
||||
DHT dht(D0, DHT11);
|
||||
```
|
||||
|
||||
Isso declara uma instância da classe `DHT` que gerencia o sensor de **D**igital umidade (**H**umidity) e **T** de temperatura. Este está conectado à porta `D0`, o soquete Grove do lado direito no Terminal Wio. O segundo parâmetro informa ao código que o sensor que está sendo usado é o sensor *DHT11* - a biblioteca que você está usando suporta outras variantes desse sensor.
|
||||
|
||||
1. Na função `setup`, adicione o código para configurar a conexão serial:
|
||||
|
||||
```cpp
|
||||
void setup()
|
||||
{
|
||||
Serial.begin(9600);
|
||||
|
||||
while (!Serial)
|
||||
; // Wait for Serial to be ready
|
||||
|
||||
delay(1000);
|
||||
}
|
||||
```
|
||||
|
||||
1. No final da função `setup`, após o último `delay`, adicione uma chamada para iniciar o sensor DHT:
|
||||
|
||||
```cpp
|
||||
dht.begin();
|
||||
```
|
||||
|
||||
1. Na função `loop`, adicione o código para chamar o sensor e imprimir a temperatura na porta serial:
|
||||
|
||||
```cpp
|
||||
void loop()
|
||||
{
|
||||
float temp_hum_val[2] = {0};
|
||||
dht.readTempAndHumidity(temp_hum_val);
|
||||
Serial.print("Temperature: ");
|
||||
Serial.print(temp_hum_val[1]);
|
||||
Serial.println ("°C");
|
||||
|
||||
delay(10000);
|
||||
}
|
||||
```
|
||||
|
||||
Este código declara um array vazio de 2 floats e passa isso para a chamada para `readTempAndHumidity` na instância `DHT`. Esta chamada preenche o array com 2 valores - a umidade vai no 0º item no array (lembre-se em arrays C++ são baseados em 0, então o 0º item é o 'primeiro' item no array), e a temperatura vai para o 1º artigo.
|
||||
|
||||
A temperatura é lida a partir do 1º item da matriz e impressa na porta serial.
|
||||
|
||||
> 🇧🇷 A temperatura é lida em Celsius. Para os americanos, para converter isso em Fahrenheit, divida o valor Celsius lido por 5, multiplique por 9 e adicione 32. Por exemplo, uma leitura de temperatura de 20°C se torna ((20/5)*9) + 32 = 68 °F.
|
||||
|
||||
1. Construa e carregue o código para o Terminal Wio.
|
||||
|
||||
> ⚠️ Você pode consultar [as instruções para criar um projeto PlatformIO no projeto 1, lição 1, se necessário](../../../../1-getting-started/lessons/1-introduction-to-iot/translations/wio-terminal.pt.md#write-the-hello-world-app).
|
||||
|
||||
1. Uma vez carregado, você pode monitorar a temperatura usando o monitor serial:
|
||||
|
||||
```output
|
||||
> Executing task: platformio device monitor <
|
||||
|
||||
--- Available filters and text transformations: colorize, debug, default, direct, hexlify, log2file, nocontrol, printable, send_on_enter, time
|
||||
--- More details at http://bit.ly/pio-monitor-filters
|
||||
--- Miniterm on /dev/cu.usbmodem1201 9600,8,N,1 ---
|
||||
--- Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H ---
|
||||
Temperature: 25.00°C
|
||||
Temperature: 25.00°C
|
||||
Temperature: 25.00°C
|
||||
Temperature: 24.00°C
|
||||
```
|
||||
|
||||
> 💁Você pode encontrar esse código na pasta [code-temperature/wio-terminal](../code-temperature/wio-terminal).
|
||||
|
||||
😀 Seu programa de sensor de temperatura foi um sucesso!
|
||||
@ -0,0 +1,292 @@
|
||||
# Conecte seu dispositivo IoT à nuvem - Terminal Wio
|
||||
|
||||
Nesta parte da lição, você conectará seu Terminal Wio ao Hub IoT para enviar telemetria e receber comandos.
|
||||
|
||||
## Conecte seu dispositivo ao Hub IoT
|
||||
|
||||
A próxima etapa é conectar seu dispositivo ao Hub IoT.
|
||||
|
||||
### Tarefa - conectar ao Hub IoT
|
||||
|
||||
1. Abra o projeto `soil-moisture-sensor` no VS Code
|
||||
|
||||
1. Abra o arquivo `platformio.ini`. Remova a dependência da biblioteca `knolleary/PubSubClient`. Isso foi usado para se conectar ao agente MQTT público e não é necessário para se conectar ao Hub IoT.
|
||||
|
||||
1. Adicione as seguintes dependências de biblioteca:
|
||||
|
||||
```ini
|
||||
seeed-studio/Seeed Arduino RTC @ 2.0.0
|
||||
arduino-libraries/AzureIoTHub @ 1.6.0
|
||||
azure/AzureIoTUtility @ 1.6.1
|
||||
azure/AzureIoTProtocol_MQTT @ 1.6.0
|
||||
azure/AzureIoTProtocol_HTTP @ 1.6.0
|
||||
azure/AzureIoTSocket_WiFi @ 1.0.2
|
||||
```
|
||||
|
||||
A biblioteca `Seeed Arduino RTC` fornece código para interagir com um relógio em tempo real no Terminal Wio, usado para rastrear o tempo. As bibliotecas restantes permitem que seu dispositivo IoT se conecte ao Hub IoT.
|
||||
|
||||
1. Adicione o seguinte na parte inferior do arquivo `platformio.ini`:
|
||||
|
||||
```ini
|
||||
build_flags =
|
||||
-DDONT_USE_UPLOADTOBLOB
|
||||
```
|
||||
|
||||
Isso define um sinalizador do compilador que é necessário ao compilar o código do Arduino IoT Hub.
|
||||
|
||||
1. Abra o arquivo de cabeçalho `config.h`. Remova todas as configurações de MQTT e adicione a seguinte constante para a string de conexão do dispositivo:
|
||||
|
||||
```cpp
|
||||
// IoT Hub settings
|
||||
const char *CONNECTION_STRING = "<connection string>";
|
||||
```
|
||||
|
||||
Substitua `<string de conexão>` pela string de conexão do seu dispositivo que você copiou anteriormente.
|
||||
|
||||
1. A conexão com o Hub IoT usa um token baseado em tempo. Isso significa que o dispositivo IoT precisa saber a hora atual. Ao contrário de sistemas operacionais como Windows, macOS ou Linux, os microcontroladores não sincronizam automaticamente a hora atual pela Internet. Isso significa que você precisará adicionar código para obter a hora atual de um servidor [NTP](https://wikipedia.org/wiki/Network_Time_Protocol). Uma vez recuperada a hora, ela pode ser armazenada em um relógio de tempo real no Terminal Wio, permitindo que a hora correta seja solicitada posteriormente, desde que o dispositivo não perca energia. Adicione um novo arquivo chamado `ntp.h` com o seguinte código:
|
||||
|
||||
```cpp
|
||||
#pragma once
|
||||
|
||||
#include "DateTime.h"
|
||||
#include <time.h>
|
||||
#include "samd/NTPClientAz.h"
|
||||
#include <sys/time.h>
|
||||
|
||||
static void initTime()
|
||||
{
|
||||
WiFiUDP _udp;
|
||||
time_t epochTime = (time_t)-1;
|
||||
NTPClientAz ntpClient;
|
||||
|
||||
ntpClient.begin();
|
||||
|
||||
while (true)
|
||||
{
|
||||
epochTime = ntpClient.getEpochTime("0.pool.ntp.org");
|
||||
|
||||
if (epochTime == (time_t)-1)
|
||||
{
|
||||
Serial.println("Fetching NTP epoch time failed! Waiting 2 seconds to retry.");
|
||||
delay(2000);
|
||||
}
|
||||
else
|
||||
{
|
||||
Serial.print("Fetched NTP epoch time is: ");
|
||||
|
||||
char buff[32];
|
||||
sprintf(buff, "%.f", difftime(epochTime, (time_t)0));
|
||||
Serial.println(buff);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ntpClient.end();
|
||||
|
||||
struct timeval tv;
|
||||
tv.tv_sec = epochTime;
|
||||
tv.tv_usec = 0;
|
||||
|
||||
settimeofday(&tv, NULL);
|
||||
}
|
||||
```
|
||||
|
||||
Os detalhes desse código estão fora do escopo desta lição. Ele define uma função chamada `initTime` que obtém a hora atual de um servidor NTP e a usa para acertar o relógio no Terminal Wio.
|
||||
|
||||
1. Abra o arquivo `main.cpp` e remova todo o código MQTT, incluindo o arquivo de cabeçalho `PubSubClient.h`, a declaração da variável `PubSubClient`, os métodos `reconnectMQTTClient` e `createMQTTClient` e quaisquer chamadas para essas variáveis e métodos. Este arquivo deve conter apenas o código para se conectar ao WiFi, obter a umidade do solo e criar um documento JSON com ele.
|
||||
|
||||
1. Adicione as seguintes diretivas `#include` à parte superior do arquivo `main.cpp` para incluir arquivos de cabeçalho para as bibliotecas do Hub IoT e para definir a hora:
|
||||
|
||||
```cpp
|
||||
#include <AzureIoTHub.h>
|
||||
#include <AzureIoTProtocol_MQTT.h>
|
||||
#include <iothubtransportmqtt.h>
|
||||
#include "ntp.h"
|
||||
```
|
||||
|
||||
1. Adicione a seguinte chamada ao final da função `setup` para definir a hora atual:
|
||||
|
||||
```cpp
|
||||
initTime();
|
||||
```
|
||||
|
||||
1. Adicione a seguinte declaração de variável ao topo do arquivo, logo abaixo das diretivas de inclusão:
|
||||
|
||||
```cpp
|
||||
IOTHUB_DEVICE_CLIENT_LL_HANDLE _device_ll_handle;
|
||||
```
|
||||
|
||||
Isso declara um `IOTHUB_DEVICE_CLIENT_LL_HANDLE`, um identificador para uma conexão com o Hub IoT.
|
||||
|
||||
1. Abaixo disso, adicione o seguinte código:
|
||||
|
||||
```cpp
|
||||
static void connectionStatusCallback(IOTHUB_CLIENT_CONNECTION_STATUS result, IOTHUB_CLIENT_CONNECTION_STATUS_REASON reason, void *user_context)
|
||||
{
|
||||
if (result == IOTHUB_CLIENT_CONNECTION_AUTHENTICATED)
|
||||
{
|
||||
Serial.println("The device client is connected to iothub");
|
||||
}
|
||||
else
|
||||
{
|
||||
Serial.println("The device client has been disconnected");
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Isso declara uma função de retorno de chamada que será chamada quando a conexão com o Hub IoT mudar de status, como conectar ou desconectar. O status é enviado para a porta serial.
|
||||
|
||||
1. Abaixo disso, adicione uma função para se conectar ao Hub IoT:
|
||||
|
||||
```cpp
|
||||
void connectIoTHub()
|
||||
{
|
||||
IoTHub_Init();
|
||||
|
||||
_device_ll_handle = IoTHubDeviceClient_LL_CreateFromConnectionString(CONNECTION_STRING, MQTT_Protocol);
|
||||
|
||||
if (_device_ll_handle == NULL)
|
||||
{
|
||||
Serial.println("Failure creating Iothub device. Hint: Check your connection string.");
|
||||
return;
|
||||
}
|
||||
|
||||
IoTHubDeviceClient_LL_SetConnectionStatusCallback(_device_ll_handle, connectionStatusCallback, NULL);
|
||||
}
|
||||
```
|
||||
|
||||
Esse código inicializa o código da biblioteca do Hub IoT e, em seguida, cria uma conexão usando a cadeia de conexão no arquivo de cabeçalho `config.h`. Esta conexão é baseada em MQTT. Se a conexão falhar, isso é enviado para a porta serial - se você vir isso na saída, verifique a string de conexão. Finalmente, o retorno de chamada do status da conexão é configurado.
|
||||
|
||||
1. Chame esta função na função `setup` abaixo da chamada para `initTime`:
|
||||
|
||||
```cpp
|
||||
connectIoTHub();
|
||||
```
|
||||
|
||||
1. Assim como no cliente MQTT, esse código é executado em um único encadeamento, portanto, precisa de tempo para processar as mensagens enviadas pelo hub e enviadas para o hub. Adicione o seguinte ao topo da função `loop` para fazer isso:
|
||||
|
||||
```cpp
|
||||
IoTHubDeviceClient_LL_DoWork(_device_ll_handle);
|
||||
```
|
||||
|
||||
1. Compile e carregue este código. Você verá a conexão no monitor serial:
|
||||
|
||||
```output
|
||||
Connecting to WiFi..
|
||||
Connected!
|
||||
Fetched NTP epoch time is: 1619983687
|
||||
Sending telemetry {"soil_moisture":391}
|
||||
The device client is connected to iothub
|
||||
```
|
||||
|
||||
Na saída, você pode ver a hora do NTP sendo buscada, seguida pela conexão do cliente do dispositivo. Pode levar alguns segundos para conectar, então você pode ver a umidade do solo na saída enquanto o dispositivo está se conectando.
|
||||
|
||||
> 💁 Você pode converter a hora do UNIX para o NTP para uma versão mais legível usando um site como [unixtimestamp.com](https://www.unixtimestamp.com)
|
||||
|
||||
## Enviar telemetria
|
||||
|
||||
Agora que seu dispositivo está conectado, você pode enviar telemetria para o Hub IoT em vez do broker MQTT.
|
||||
|
||||
### Tarefa - enviar telemetria
|
||||
|
||||
1. Adicione a seguinte função acima da função `setup`:
|
||||
|
||||
```cpp
|
||||
void sendTelemetry(const char *telemetry)
|
||||
{
|
||||
IOTHUB_MESSAGE_HANDLE message_handle = IoTHubMessage_CreateFromString(telemetry);
|
||||
IoTHubDeviceClient_LL_SendEventAsync(_device_ll_handle, message_handle, NULL, NULL);
|
||||
IoTHubMessage_Destroy(message_handle);
|
||||
}
|
||||
```
|
||||
|
||||
Esse código cria uma mensagem do Hub IoT a partir de uma string passada como parâmetro, a envia para o Hub e, em seguida, limpa o objeto de mensagem.
|
||||
|
||||
1. Chame este código na função `loop`, logo após a linha onde a telemetria é enviada para a porta serial:
|
||||
|
||||
```cpp
|
||||
sendTelemetry(telemetry.c_str());
|
||||
```
|
||||
|
||||
## Manipular comandos
|
||||
|
||||
Seu dispositivo precisa lidar com um comando do código do servidor para controlar a retransmissão. Isso é enviado como uma solicitação de método direto.
|
||||
|
||||
## Tarefa - lidar com uma solicitação de método direto
|
||||
|
||||
1. Adicione o seguinte código antes da função `connectIOTHub`:
|
||||
|
||||
```cpp
|
||||
int directMethodCallback(const char *method_name, const unsigned char *payload, size_t size, unsigned char **response, size_t *response_size, void *userContextCallback)
|
||||
{
|
||||
Serial.printf("Direct method received %s\r\n", method_name);
|
||||
|
||||
if (strcmp(method_name, "relay_on") == 0)
|
||||
{
|
||||
digitalWrite(PIN_WIRE_SCL, HIGH);
|
||||
}
|
||||
else if (strcmp(method_name, "relay_off") == 0)
|
||||
{
|
||||
digitalWrite(PIN_WIRE_SCL, LOW);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Esse código define um método de retorno de chamada que a biblioteca do Hub IoT pode chamar quando recebe uma solicitação de método direto. O método solicitado é enviado no parâmetro `method_name`. Esta função imprime o método chamado para a porta serial, então liga ou desliga o relé dependendo do nome do método.
|
||||
|
||||
> 💁 Isso também pode ser implementado em uma única solicitação direta de método, passando o estado desejado do relé em uma carga útil que pode ser passada com a solicitação do método e disponível a partir do parâmetro `payload`.
|
||||
|
||||
1. Adicione o seguinte código ao final da função `directMethodCallback`:
|
||||
|
||||
```cpp
|
||||
char resultBuff[16];
|
||||
sprintf(resultBuff, "{\"Result\":\"\"}");
|
||||
*response_size = strlen(resultBuff);
|
||||
*response = (unsigned char *)malloc(*response_size);
|
||||
memcpy(*response, resultBuff, *response_size);
|
||||
|
||||
return IOTHUB_CLIENT_OK;
|
||||
```
|
||||
|
||||
As solicitações de método direto precisam de uma resposta, e a resposta está em duas partes - uma resposta como texto e um código de retorno. Este código criará um resultado como o seguinte documento JSON:
|
||||
|
||||
```JSON
|
||||
{
|
||||
"Result": ""
|
||||
}
|
||||
```
|
||||
|
||||
Isso é então copiado para o parâmetro `response`, e o tamanho dessa resposta é definido no parâmetro `response_size`. Este código então retorna `IOTHUB_CLIENT_OK` para mostrar que o método foi tratado corretamente.
|
||||
|
||||
1. Conecte o retorno de chamada adicionando o seguinte ao final da função `connectIOTHub`:
|
||||
|
||||
```cpp
|
||||
IoTHubClient_LL_SetDeviceMethodCallback(_device_ll_handle, directMethodCallback, NULL);
|
||||
```
|
||||
|
||||
1. A função `loop` chamará a função `IOTHubDeviceClient_LL_DoWork` para processar eventos enviados pelo Hub IoT. Isso só é chamado a cada 10 segundos devido ao `delay`, significando que os métodos diretos são processados apenas a cada 10 segundos. Para tornar isso mais eficiente, o atraso de 10 segundos pode ser implementado como muitos atrasos menores, chamando `IOTHubDeviceClient_LL_DoWork` a cada vez. Para fazer isso, adicione o seguinte código acima da função `loop`:
|
||||
|
||||
```cpp
|
||||
void work_delay(int delay_time)
|
||||
{
|
||||
int current = 0;
|
||||
do
|
||||
{
|
||||
IoTHubDeviceClient_LL_DoWork(_device_ll_handle);
|
||||
delay(100);
|
||||
current += 100;
|
||||
} while (current < delay_time);
|
||||
}
|
||||
```
|
||||
|
||||
Esse código fará um loop repetidamente, chamando `IOTHubDeviceClient_LL_DoWork` e atrasando por 100ms cada vez. Ele fará isso quantas vezes forem necessárias para atrasar a quantidade de tempo fornecida no parâmetro `delay_time`. Isso significa que o dispositivo está aguardando no máximo 100 ms para processar solicitações de métodos diretos.
|
||||
|
||||
1. Na função `loop`, remova a chamada para `IOTHubDeviceClient_LL_DoWork` e substitua a chamada `delay(10000)` pelo seguinte para chamar esta nova função:
|
||||
|
||||
```cpp
|
||||
work_delay(10000);
|
||||
```
|
||||
|
||||
> 💁 Você pode encontrar este código na pasta [code/wio-terminal](../code/wio-terminal).
|
||||
|
||||
😀 Seu programa de sensor de umidade do solo está conectado ao seu Hub IoT!
|
||||
@ -0,0 +1,20 @@
|
||||
# Fazendo com IoT
|
||||
|
||||
À medida que a população cresce, o mesmo acontece com a demanda na agricultura. A quantidade de terra disponível não muda, mas o clima sim - dando ainda mais desafios aos agricultores, especialmente aos 2 bilhões [agricultores de subsistência](https://wikipedia.org/wiki/Subsistence_agriculture) que dependem do que cultivam para poder comer e alimentar suas famílias. A IoT pode ajudar os agricultores a tomar decisões mais inteligentes sobre o que cultivar e quando colher, aumentar os rendimentos, reduzir a quantidade de trabalho manual e detectar e lidar com pragas.
|
||||
|
||||
Nestas 6 lições, você aprenderá como aplicar a Internet das Coisas para melhorar e automatizar a agricultura.
|
||||
|
||||
> 💁 Essas lições usarão alguns recursos de nuvem. Se você não concluir todas as lições deste projeto, certifique-se de [limpar seu projeto](../../translations/clean-up.pt.md).
|
||||
|
||||
## Topics
|
||||
|
||||
1. [Preveja o crescimento da planta com IoT](lessons/1-predict-plant-growth/README.md)
|
||||
1. [Detectar a umidade do solo](lessons/2-detect-soil-moisture/README.md)
|
||||
1. [Rega automática de plantas](lessons/3-automated-plant-watering/README.md)
|
||||
1. [Migre sua planta para a nuvem](lessons/4-migrate-your-plant-to-the-cloud/README.md)
|
||||
1. [Migre a lógica do seu aplicativo para a nuvem](lessons/5-migrate-application-to-the-cloud/README.md)
|
||||
1. [Mantenha sua planta segura](lessons/6-keep-your-plant-secure/README.md)
|
||||
|
||||
## Creditos
|
||||
|
||||
Todas as lições foram escritas com ♥️ por [Jim Bennett](https://GitHub.com/JimBobBennett)
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,41 @@
|
||||
# Limpando seu projeto
|
||||
|
||||
Depois de concluir cada projeto, é bom excluir seus recursos de nuvem.
|
||||
|
||||
Nas lições de cada projeto, você pode ter criado alguns dos itens a seguir:
|
||||
|
||||
* Um grupo de recursos
|
||||
* Um Hub IoT
|
||||
* Registros de dispositivos IoT
|
||||
* Uma conta de armazenamento
|
||||
* Um aplicativo de funções
|
||||
* Uma conta do Azure Mapas
|
||||
* Um projeto de visão personalizado
|
||||
* Um Registro de Contêiner do Azure
|
||||
* Um recurso de serviços cognitivos
|
||||
|
||||
A maioria desses recursos não terá custo - ou eles são totalmente gratuitos ou você está usando um nível gratuito. Para serviços que exigem um nível pago, você os usaria em um nível incluído no subsídio gratuito ou custaria apenas alguns centavos.
|
||||
|
||||
Mesmo com os custos relativamente baixos, vale a pena excluir esses recursos quando terminar. Você só pode ter um Hub IoT usando o nível gratuito, por exemplo, portanto, se quiser criar outro, precisará usar um nível pago.
|
||||
|
||||
Todos os seus serviços foram criados dentro de Grupos de Recursos, e isso facilita o gerenciamento. Você pode excluir o Grupo de Recursos e todos os serviços desse Grupo de Recursos serão excluídos junto com ele.
|
||||
|
||||
Para excluir o grupo de recursos, execute o seguinte comando em seu terminal ou prompt de comando:
|
||||
|
||||
```sh
|
||||
az group delete --name <resource-group-name>
|
||||
```
|
||||
|
||||
Substitua `<resource-group-name>` com o nome do Grupo de Recursos no qual você está interessado.
|
||||
|
||||
Uma confirmação aparecerá:
|
||||
|
||||
```output
|
||||
Are you sure you want to perform this operation? (y/n):
|
||||
```
|
||||
|
||||
Digite `y` para confirmar e excluir o grupo de recursos.
|
||||
|
||||
Pode demorar um pouco para excluir todos os serviços.
|
||||
|
||||
> 💁 Você pode ler mais sobre como excluir grupos de recursos no [Grupo de recursos do Azure Resource Manager e documentação de exclusão de recursos no Microsoft Docs](https://docs.microsoft.com/azure/azure-resource-manager/management/delete-resource-group?WT.mc_id=academic-17441-jabenn&tabs=azure-cli)
|
||||
Loading…
Reference in new issue