From 8d060c3b5557cd9be570c64d154a193833bb007e Mon Sep 17 00:00:00 2001 From: weslleylmurdock Date: Sat, 8 Oct 2022 06:42:23 -0300 Subject: [PATCH 1/2] Add pt-br translation for 2-farm --- .../translations/README.pt.md | 455 +++ .../translations/assignment.pt.md | 14 + .../translations/wio-terminal-mqtt.pt.md | 0 .../translations/README.pt.md | 269 ++ .../translations/assignment.pt.md | 43 + .../translations/pi-temp.pt.md | 111 + .../single-board-computer-temp-publish.md | 57 + .../translations/virtual-device-temp.pt.md | 140 + .../wio-terminal-temp-publish.pt.md | 68 + .../translations/wio-terminal-temp.pt.md | 129 + .../wio-terminal-connect-hub.pt.md | 292 ++ 2-farm/translations/README.pt.md | 20 + quiz-app/src/assets/translations/pt.json | 2461 +++++++++++++++++ translations/clean-up.pt.md | 41 + 14 files changed, 4100 insertions(+) create mode 100644 1-getting-started/lessons/4-connect-internet/translations/README.pt.md create mode 100644 1-getting-started/lessons/4-connect-internet/translations/assignment.pt.md create mode 100644 1-getting-started/lessons/4-connect-internet/translations/wio-terminal-mqtt.pt.md create mode 100644 2-farm/lessons/1-predict-plant-growth/translations/README.pt.md create mode 100644 2-farm/lessons/1-predict-plant-growth/translations/assignment.pt.md create mode 100644 2-farm/lessons/1-predict-plant-growth/translations/pi-temp.pt.md create mode 100644 2-farm/lessons/1-predict-plant-growth/translations/single-board-computer-temp-publish.md create mode 100644 2-farm/lessons/1-predict-plant-growth/translations/virtual-device-temp.pt.md create mode 100644 2-farm/lessons/1-predict-plant-growth/translations/wio-terminal-temp-publish.pt.md create mode 100644 2-farm/lessons/1-predict-plant-growth/translations/wio-terminal-temp.pt.md create mode 100644 2-farm/lessons/4-migrate-your-plant-to-the-cloud/translations/wio-terminal-connect-hub.pt.md create mode 100644 2-farm/translations/README.pt.md create mode 100644 quiz-app/src/assets/translations/pt.json create mode 100644 translations/clean-up.pt.md diff --git a/1-getting-started/lessons/4-connect-internet/translations/README.pt.md b/1-getting-started/lessons/4-connect-internet/translations/README.pt.md new file mode 100644 index 00000000..e0b8b979 --- /dev/null +++ b/1-getting-started/lessons/4-connect-internet/translations/README.pt.md @@ -0,0 +1,455 @@ +# Conecte seu dispositivo à Internet + +![Uma visão geral do sketchnote desta lição](../../../sketchnotes/lesson-4.jpg) + +> 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. + +[![Lição 4: Conecte seu dispositivo à Internet](https://img.youtube.com/vi/O4dd172mZhs/0.jpg)](https://youtu.be/O4dd172mZhs) + +[![Lição 4: Conecte seu dispositivo à Internet - Horário comercial](https://img.youtube.com/vi/j-cVCzRDE2Q/0.jpg)](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. + +![Os dispositivos IoT se conectam a um broker e publicam telemetria e assinam comandos. Os serviços em nuvem se conectam ao broker e assinam toda a telemetria e enviam comandos para dispositivos específicos.](../../../../images/pub-sub.png) + +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. + +![telemetria de publicação de dispositivo IoT no tópico /telemetry e o serviço de nuvem assinando esse tópico](../../../../images/mqtt.png) + +✅ 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 + +![Um fluxograma da atribuição mostrando os níveis de luz sendo lidos e verificados, e o LED começa a ser controlado](../../../../images/assignment-1-internet-flow.png) + +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. + +![Um termostato conectado à Internet usando vários sensores de ambiente](../../../../images/telemetry.png) + +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: + + ![VS Code mostrando o ambiente virtual selecionado](../../../images/vscode-virtual-env.png) + +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**: + + ![VS Code Kill the active terminal instance button](../../../images/vscode-kill-terminal.png) + +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 = '' + + 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 `` 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. + +[![Este ferrari foi emparedado porque alguém tentou atualizá-lo no subsolo, onde não há recepção de celular](../../../../images/bricked-car.png)](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 conectado à Internet recebendo um comando para ligar o aquecimento](../../../images/commands.png) + +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) diff --git a/1-getting-started/lessons/4-connect-internet/translations/assignment.pt.md b/1-getting-started/lessons/4-connect-internet/translations/assignment.pt.md new file mode 100644 index 00000000..01e724a9 --- /dev/null +++ b/1-getting-started/lessons/4-connect-internet/translations/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. | diff --git a/1-getting-started/lessons/4-connect-internet/translations/wio-terminal-mqtt.pt.md b/1-getting-started/lessons/4-connect-internet/translations/wio-terminal-mqtt.pt.md new file mode 100644 index 00000000..e69de29b diff --git a/2-farm/lessons/1-predict-plant-growth/translations/README.pt.md b/2-farm/lessons/1-predict-plant-growth/translations/README.pt.md new file mode 100644 index 00000000..91843622 --- /dev/null +++ b/2-farm/lessons/1-predict-plant-growth/translations/README.pt.md @@ -0,0 +1,269 @@ +# Preveja o crescimento da planta com IoT + +![Uma visão geral do sketchnote desta lição](../../../../sketchnotes/lesson-5.jpg) + +> Sketchnote por [Nitya Narasimhan](https://github.com/nitya). Clique na imagem para uma versão maior. + +## Teste pré-aula + +[Teste pré-aula](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/9) + +## Introdução + +As plantas precisam de certas coisas para crescer - água, dióxido de carbono, nutrientes, luz e calor. Nesta lição, você aprenderá a calcular as taxas de crescimento e maturidade das plantas medindo a temperatura do ar. + +Nesta lição abordaremos: + +* [Agricultura digital](#agricultura-digital) +* [Por que a temperatura é importante na agricultura?](#por-que-a-temperatura-é-importante-na-agricultura?) +* [Medir a temperatura ambiente](#medir-a-temperatura-ambiente) +* [Graus-dias crescentes (GDD)](#graus-dias-crescentes) +* [Calcular GDD usando dados do sensor de temperatura](#calculate-gdd-using-temperature-sensor-data) + +## Agricultura Digital + +A Agricultura Digital está transformando a forma como cultivamos, usando ferramentas para coletar, armazenar e analisar dados da agricultura. Estamos atualmente em um período descrito como a 'Quarta Revolução Industrial' pelo Fórum Econômico Mundial, e a ascensão da agricultura digital foi rotulada como a 'Quarta Revolução Agrícola', ou 'Agricultura 4.0'. + +> 🎓 O termo Agricultura Digital também inclui toda a 'cadeia de valor da agricultura', que é toda a jornada da fazenda à mesa. Inclui o rastreamento da qualidade dos produtos à medida que os alimentos são enviados e processados, sistemas de armazém e comércio eletrônico, até mesmo aplicativos de aluguel de tratores! + +Essas mudanças permitem que os agricultores aumentem os rendimentos, usem menos fertilizantes e pesticidas e reguem com mais eficiência. Embora usados principalmente em nações mais ricas, sensores e outros dispositivos estão diminuindo lentamente de preço, tornando-os mais acessíveis em países em desenvolvimento. + +Algumas técnicas habilitadas pela agricultura digital são: + +* Medição de temperatura - a medição de temperatura permite que os agricultores prevejam o crescimento e a maturidade das plantas. +* Rega automatizada - medindo a umidade do solo e ligando os sistemas de irrigação quando o solo está muito seco, em vez de regar com tempo. A rega cronometrada pode levar a que as colheitas sejam subregadas durante um período quente e seco ou regadas em excesso durante a chuva. Ao regar apenas quando o solo precisa, os agricultores podem otimizar o uso da água. +* Controle de pragas - os agricultores podem usar câmeras em robôs automatizados ou drones para verificar se há pragas e, em seguida, aplicar pesticidas apenas onde necessário, reduzindo a quantidade de pesticidas usados e reduzindo o escoamento de pesticidas no abastecimento de água local. + +✅ Pesquise. Que outras técnicas são usadas para melhorar os rendimentos agrícolas? + +> 🎓 O termo 'Agricultura de Precisão' é usado para definir a observação, medição e resposta às culturas por campo, ou mesmo em partes de um campo. Isso inclui medir os níveis de água, nutrientes e pragas e responder com precisão, como regar apenas uma pequena parte de um campo. + +## Por que a temperatura é importante na agricultura? + +Ao aprender sobre plantas, a maioria dos alunos é ensinada sobre a necessidade de água, luz, dióxido de carbono (CO2) e nutrientes. As plantas também precisam de calor para crescer - é por isso que as plantas florescem na primavera à medida que a temperatura aumenta, por que os flocos de neve ou narcisos podem brotar cedo devido a um curto período de calor e por que as estufas e estufas são tão boas para fazer as plantas crescerem. + +> 🎓 Estufas e estufas fazem um trabalho semelhante, mas com uma diferença importante. As estufas são aquecidas artificialmente e permitem que os agricultores controlem as temperaturas com mais precisão, as estufas dependem do sol para se aquecer e geralmente o único controle são as janelas ou outras aberturas para deixar o calor sair. + +As plantas têm uma temperatura base ou mínima, temperatura ótima e temperatura máxima, todas baseadas nas temperaturas médias diárias. + +* Temperatura base - esta é a temperatura média diária mínima necessária para que uma planta cresça. +* Temperatura ideal - esta é a melhor temperatura média diária para obter o maior crescimento. +* Temperatura máxima - É a temperatura máxima que uma planta pode suportar. Acima disso, a planta interromperá seu crescimento na tentativa de conservar a água e permanecer viva. + +> 💁 Estas são temperaturas médias, calculadas sobre as temperaturas diárias e noturnas. As plantas também precisam de temperaturas diferentes dia e noite para ajudá-las a fotossintetizar com mais eficiência e economizar energia à noite. + +Cada espécie de planta tem valores diferentes para sua base, ótima e máxima. É por isso que algumas plantas prosperam em países quentes e outras em países mais frios. + +✅ Pesquise. Para quaisquer plantas que você tenha em seu jardim, escola ou parque local, veja se consegue encontrar a temperatura base. + +![Um gráfico mostrando a taxa de crescimento aumentando à medida que a temperatura aumenta e depois caindo à medida que a temperatura fica muito alta](../../../../images/plant-growth-temp-graph.png) + +O gráfico acima mostra um exemplo de gráfico de taxa de crescimento para temperatura. Até a temperatura base não há crescimento. A taxa de crescimento aumenta até a temperatura ótima, depois cai após atingir esse pico. Na temperatura máxima o crescimento para. + +A forma deste gráfico varia de espécie de planta para espécie de planta. Alguns têm quedas mais acentuadas acima do ótimo, alguns têm aumentos mais lentos da base para o ótimo. + +> 💁 Para um agricultor obter o melhor crescimento, ele precisará conhecer os três valores de temperatura e entender a forma dos gráficos para as plantas que estão cultivando. + +Se um agricultor tem controle de temperatura, por exemplo, em uma estufa comercial, ele pode otimizar suas plantas. Uma estufa comercial que cultiva tomates, por exemplo, terá a temperatura definida para cerca de 25°C durante o dia e 20°C à noite para obter o crescimento mais rápido. + +> 🍅 A combinação dessas temperaturas com luzes artificiais, fertilizantes e níveis controlados de CO2 significa que os produtores comerciais podem cultivar e colher durante todo o ano. + +## Medir a temperatura ambiente + +Sensores de temperatura podem ser usados com dispositivos IoT para medir a temperatura ambiente. + +### Tarefa - medir a temperatura + +Trabalhe com o guia relevante para monitorar as temperaturas usando seu dispositivo IoT: + +* [Arduino - Wio Terminal](wio-terminal-temp.pt.md) +* [Single-board computer - Raspberry Pi](pi-temp.pt.md) +* [Single-board computer - Virtual device](virtual-device-temp.pt.md) + +## Graus-dias crescentes + +Os graus-dia de crescimento (também conhecidos como unidades de graus de crescimento) são uma maneira de medir o crescimento das plantas com base na temperatura. Assumindo que uma planta tem bastante água, nutrientes e CO2, a temperatura determina a taxa de crescimento. + +Os graus-dia crescentes, ou GDD, são calculados por dia como a temperatura média em Celsius para um dia acima da temperatura base da planta. Cada planta precisa de um certo número de GDD para crescer, florescer ou produzir e amadurecer uma safra. Quanto mais GDD a cada dia, mais rápido a planta crescerá. + +> 🇧🇷 Para os americanos, graus-dia crescentes também podem ser calculados usando Fahrenheit. 5 GDDC (graus-dias crescentes em Celsius) é o equivalente a 9 GDDF (graus-dias crescentes em Fahrenheit). + +A fórmula completa para o GDD é um pouco complicada, mas existe uma equação simplificada que costuma ser usada como uma boa aproximação: + +![GDD = T max + T min dividido por 2, tudo menos T base](../../../../images/gdd-calculation.png) + +* **GDD** - este é o número de graus-dia crescentes +* **Tmax** - esta é a temperatura máxima diária em graus Celsius +* **Tmin** - esta é a temperatura mínima diária em graus Celsius +* **Tbase** - esta é a temperatura base das plantas em graus Celsius + +> 💁 Existem variações que lidam com Tmax acima de 30°C ou Tmin abaixo de Tbase, mas vamos ignorá-las por enquanto. + +### Exemplo - Milho 🌽 + +Dependendo da variedade, o milho (ou milho) precisa entre 800 e 2.700 GDD para amadurecer, com temperatura base de 10°C. + +No primeiro dia acima da temperatura base, foram medidas as seguintes temperaturas: + +| Measurement | Temp °C | +| :---------- | :-----: | +| Máximo | 16 | +| Mínimo | 12 | + +Colocando esses números em nosso cálculo: + +* Tmax = 16 +* Tmin = 12 +* Tbase = 10 + +Isso dá um cálculo de: + +![GDD = 16 + 12 dividido por 2, tudo menos 10, resultando 4](../../../../images/gdd-calculation-corn.png) + +O milho recebeu 4 GDD naquele dia. Assumindo uma variedade de milho que precisa de 800 dias de GDD para amadurecer, precisará de outros 796 GDD para atingir a maturidade. + +✅ Pesquise. Para quaisquer plantas que você tenha em seu jardim, escola ou parque local, veja se consegue encontrar o número de GDD necessário para atingir a maturidade ou produzir colheitas. + +## Calcular GDD usando dados do sensor de temperatura + +As plantas não crescem em datas fixas - por exemplo, você não pode plantar uma semente e saber que a planta dará frutos exatamente 100 dias depois. Em vez disso, como agricultor, você pode ter uma ideia aproximada de quanto tempo uma planta leva para crescer, então você verificaria diariamente para ver quando as colheitas estavam prontas. + +Isso tem um enorme impacto trabalhista em uma grande fazenda e corre o risco de o agricultor perder colheitas que estão prontas inesperadamente cedo. Ao medir as temperaturas, o agricultor pode calcular o GDD que uma planta recebeu, permitindo que ele verifique apenas próximo à maturidade esperada. + +Ao coletar dados de temperatura usando um dispositivo IoT, um agricultor pode ser notificado automaticamente quando as plantas estiverem próximas da maturidade. Uma arquitetura típica para isso é fazer com que os dispositivos IoT meçam a temperatura e, em seguida, publiquem esses dados de telemetria pela Internet usando algo como MQTT. O código do servidor então escuta esses dados e os salva em algum lugar, como em um banco de dados. Isso significa que os dados podem ser analisados ​​posteriormente, como um trabalho noturno para calcular o GDD do dia, totalizar o GDD para cada safra até o momento e alertar se uma planta estiver próxima da maturidade. + +![Os dados de telemetria são enviados para um servidor e salvos em um banco de dados](../../../../images/save-telemetry-database.png) + +O código do servidor também pode aumentar os dados adicionando informações extras. Por exemplo, o dispositivo IoT pode publicar um identificador para indicar qual é o dispositivo, e o código do servidor pode usar isso para pesquisar a localização do dispositivo e quais culturas ele está monitorando. Ele também pode adicionar dados básicos, como a hora atual, pois alguns dispositivos IoT não possuem o hardware necessário para acompanhar uma hora exata ou exigem código adicional para ler a hora atual pela Internet. + +✅ Por que você acha que campos diferentes podem ter temperaturas diferentes? + +### Tarefa - publicar informações de temperatura + +Trabalhe com o guia relevante para publicar dados de temperatura no MQTT usando seu dispositivo IoT para que possam ser analisados posteriormente: + +* [Arduino - Wio Terminal](wio-terminal-temp-publish.pt.md) +* [Single-board computer - Raspberry Pi/Virtual IoT device](single-board-computer-temp-publish.pt.md) + +### Tarefa - capturar e armazenar as informações de temperatura + +Depois que o dispositivo IoT estiver publicando a telemetria, o código do servidor pode ser escrito para assinar esses dados e armazená-los. Em vez de salvá-lo em um banco de dados, o código do servidor o salvará em um arquivo de valores separados por vírgula (CSV). Os arquivos CSV armazenam dados como linhas de valores como texto, com cada valor separado por uma vírgula e cada registro em uma nova linha. Eles são uma maneira conveniente, legível e bem suportada de salvar dados como um arquivo. + +O arquivo CSV terá duas colunas - *data* e *temperatura*. A coluna *data* é definida como a data e hora atuais em que a mensagem foi recebida pelo servidor, a *temperatura* vem da mensagem de telemetria. + +1. Repita as etapas na lição 4 para criar o código do servidor para assinar a telemetria. Você não precisa adicionar código para publicar comandos. + + Os passos para isso são: + + * Configurar e ativar um ambiente virtual Python + + * Instale o pacote pip paho-mqtt + + * Escreva o código para escutar mensagens MQTT publicadas no tópico de telemetria + + > ⚠️ Você pode consultar [as instruções na lição 4 para criar um aplicativo Python para receber telemetria, se necessário](../../../../1-getting-started/lessons/4-connect-internet/translations/README.pt.md#receber-telemetria-do-broker-mqtt). + + Nomeie a pasta para este projeto `temperature-sensor-server`. + +1. Certifique-se de `client_name` reflete este projeto: + + ```cpp + client_name = id + 'temperature_sensor_server' + ``` + +1. Adicione as seguintes importações ao topo do arquivo, abaixo das importações existentes: + + ```python + from os import path + import csv + from datetime import datetime + ``` + + Isso importa uma biblioteca para leitura de arquivos, uma biblioteca para interagir com arquivos CSV e uma biblioteca para ajudar com datas e horas. + +1. Adicione o seguinte código antes da função `handle_telemetry`: + + ```python + temperature_file_name = 'temperature.csv' + fieldnames = ['date', 'temperature'] + + if not path.exists(temperature_file_name): + with open(temperature_file_name, mode='w') as csv_file: + writer = csv.DictWriter(csv_file, fieldnames=fieldnames) + writer.writeheader() + ``` + + Esse código declara algumas constantes para o nome do arquivo no qual gravar e o nome dos cabeçalhos de coluna do arquivo CSV. A primeira linha de um arquivo CSV tradicionalmente contém cabeçalhos de coluna separados por vírgulas. + + O código então verifica se o arquivo CSV já existe. Se não existir, será criado com os cabeçalhos das colunas na primeira linha. + +1. Adicione o seguinte código ao final da função `handle_telemetry`: + + ```python + with open(temperature_file_name, mode='a') as temperature_file: + temperature_writer = csv.DictWriter(temperature_file, fieldnames=fieldnames) + temperature_writer.writerow({'date' : datetime.now().astimezone().replace(microsecond=0).isoformat(), 'temperature' : payload['temperature']}) + ``` + + Esse código abre o arquivo CSV e anexa uma nova linha no final. A linha tem os dados atuais e a hora formatados em um formato legível, seguido pela temperatura recebida do dispositivo IoT. Os dados são armazenados no [formato ISO 8601](https://wikipedia.org/wiki/ISO_8601) com o fuso horário, mas sem microssegundos. + +1. Execute este código da mesma forma que antes, certificando-se de que seu dispositivo IoT está enviando dados. Um arquivo CSV chamado `temperature.csv` será criado na mesma pasta. Se você visualizá-lo, verá as medições de data/hora e temperatura: + + ```output + date,temperature + 2021-04-19T17:21:36-07:00,25 + 2021-04-19T17:31:36-07:00,24 + 2021-04-19T17:41:36-07:00,25 + ``` + +1. Execute este código por um tempo para capturar dados. Idealmente, você deve executar isso por um dia inteiro para coletar dados suficientes para cálculos de GDD. + + > 💁 Se você estiver usando o dispositivo IoT virtual, marque a caixa de seleção aleatória e defina um intervalo para evitar obter a mesma temperatura toda vez que o valor da temperatura for retornado. + ![Marque a caixa de seleção aleatória e defina um intervalo](../../../../images/select-the-random-checkbox-and-set-a-range.png) + + > 💁 Se você quiser executar isso por um dia inteiro, precisará garantir que o computador no qual o código do servidor está sendo executado não entre no modo de suspensão, alterando suas configurações de energia ou executando algo como [este script em python para manter o sistema ativo](https://github.com/jaqsparow/keep-system-active). + +> 💁 Você pode encontrar este código na pasta [code-server/temperature-sensor-server](../code-server/temperature-sensor-server). + +### Tarefa - calcular GDD usando os dados armazenados + +Uma vez que o servidor tenha capturado os dados de temperatura, o GDD de uma planta pode ser calculado. + +As etapas para fazer isso manualmente são: + +1. Encontre a temperatura base para a planta. Por exemplo, para morangos a temperatura base é 10°C. + +1. A partir do arquivo `temperature.csv`, encontre as temperaturas mais altas e mais baixas do dia + +1. Use o cálculo de GDD fornecido anteriormente para calcular o GDD + +Por exemplo, se a temperatura mais alta do dia for 25°C e a mais baixa for 12°C: + +![GDD = 25 + 12 dividido por 2, então subtrair 10 do resultado retornando 8.5](../../../../images/gdd-calculation-strawberries.png) + +* 25 + 12 = 37 +* 37 / 2 = 18.5 +* 18.5 - 10 = 8.5 + +Portanto, os morangos receberam **8,5** GDD. Morangos precisam de cerca de 250 GDD para dar frutos, então ainda falta um tempo. +--- + +## 🚀 Desafio + +As plantas precisam de mais do que calor para crescer. Que outras coisas são necessárias? + +Para estes, descubra se existem sensores que possam medi-los. E os atuadores para controlar esses níveis? Como você montaria um ou mais dispositivos IoT para otimizar o crescimento da planta? + +## Questionário pós-aula + +[Questionário pós-aula](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/10) + +## Revisão e autoestudo + +* Leia mais sobre agricultura digital na [página da Wikipedia sobre agricultura digital](https://wikipedia.org/wiki/Digital_agriculture). Leia também mais sobre agricultura de precisão na [página da Wikipedia sobre agricultura de precisão](https://wikipedia.org/wiki/Precision_agriculture). +* O cálculo completo dos graus-dias de crescimento é mais complicado do que o simplificado fornecido aqui. Leia mais sobre a equação mais complicada e como lidar com temperaturas abaixo da linha de base na [página da Wikipedia sobre Growing Degree Day](https://wikipedia.org/wiki/Growing_degree-day). +* A comida pode ser escassa no futuro, mesmo que ainda usemos os mesmos métodos para a agricultura. Saiba mais sobre técnicas agrícolas de alta tecnologia neste [Vídeo Hi-Tech Farms of Future no YouTube](https://www.youtube.com/watch?v=KIEOuKD9KX8). + +## Tarefa + +[Visualize dados GDD usando um Jupyter Notebook](assignment.pt.md) diff --git a/2-farm/lessons/1-predict-plant-growth/translations/assignment.pt.md b/2-farm/lessons/1-predict-plant-growth/translations/assignment.pt.md new file mode 100644 index 00000000..57d55747 --- /dev/null +++ b/2-farm/lessons/1-predict-plant-growth/translations/assignment.pt.md @@ -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. + + ![O notebook jupyter](../../../../images/gdd-jupyter-notebook.png) + +## 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 | diff --git a/2-farm/lessons/1-predict-plant-growth/translations/pi-temp.pt.md b/2-farm/lessons/1-predict-plant-growth/translations/pi-temp.pt.md new file mode 100644 index 00000000..630efc84 --- /dev/null +++ b/2-farm/lessons/1-predict-plant-growth/translations/pi-temp.pt.md @@ -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 + +![Um sensor de temperatura groove](../../../../images/grove-dht11.png) + +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. + +![O sensor de temperatura Grove conectado ao soquete A0](../../../../images/pi-temperature-sensor.png) + +## 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! diff --git a/2-farm/lessons/1-predict-plant-growth/translations/single-board-computer-temp-publish.md b/2-farm/lessons/1-predict-plant-growth/translations/single-board-computer-temp-publish.md new file mode 100644 index 00000000..214c35c2 --- /dev/null +++ b/2-farm/lessons/1-predict-plant-growth/translations/single-board-computer-temp-publish.md @@ -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. diff --git a/2-farm/lessons/1-predict-plant-growth/translations/virtual-device-temp.pt.md b/2-farm/lessons/1-predict-plant-growth/translations/virtual-device-temp.pt.md new file mode 100644 index 00000000..ef633465 --- /dev/null +++ b/2-farm/lessons/1-predict-plant-growth/translations/virtual-device-temp.pt.md @@ -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 + + ![As configurações do sensor de umidade](../../../../images/counterfit-create-humidity-sensor.png) + + O sensor de umidade será criado e aparecerá na lista de sensores. + + ![O sensor de umidade foi criado](../../../../images/counterfit-humidity-sensor.png) + +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 + + ![As configurações do sensor de temperatura](../../../../images/counterfit-create-temperature-sensor.png) + + O sensor de temperatura será criado e aparecerá na lista de sensores. + + ![O sensor de temperatura criado](../../../../images/counterfit-temperature-sensor.png) + +## 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! diff --git a/2-farm/lessons/1-predict-plant-growth/translations/wio-terminal-temp-publish.pt.md b/2-farm/lessons/1-predict-plant-growth/translations/wio-terminal-temp-publish.pt.md new file mode 100644 index 00000000..d72807b4 --- /dev/null +++ b/2-farm/lessons/1-predict-plant-growth/translations/wio-terminal-temp-publish.pt.md @@ -0,0 +1,68 @@ +# Temperatura de publicação - Terminal Wio + +Nesta parte da lição, você publicará os valores de temperatura detectados pelo Terminal Wio 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. Os microcontroladores não leem a hora da Internet e rastreiam a hora com um relógio em tempo real pronto para uso, o dispositivo precisa ser programado para fazer isso, desde que tenha o hardware necessário. + +Para simplificar as coisas para esta lição, a hora não será enviada com os dados do sensor, mas poderá ser adicionada pelo código do servidor posteriormente quando receber as mensagens. + +### Tarefa + +Programe o dispositivo para publicar os dados de temperatura. + +1. Abra o projeto do Terminal Wio `temperature-sensor` + +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 as bibliotecas Seeed WiFi e MQTT ao arquivo `.ini` + - Adicione o arquivo de configuração e o código para se conectar ao WiFi + - Adicione o código para se conectar ao broker MQTT + - Adicione o código para publicar a telemetria + + > ⚠️ Consulte as [instruções para se conectar ao MQTT](../../../../../1-getting-started/lessons/4-connect-internet/translations/wio-terminal-mqtt.pt.md) e as [instruções para enviar telemetria](../../../1-getting-started/lessons/4-connect-internet/wio-terminal-telemetry.md) da lição 4, se necessário. + +1. Certifique-se de que o `CLIENT_NAME` no arquivo de cabeçalho `config.h` reflita este projeto: + + ```cpp + const string 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` alterando a função `loop` em `main.cpp`: + + ```cpp + float temp_hum_val[2] = {0}; + dht.readTempAndHumidity(temp_hum_val); + + DynamicJsonDocument doc(1024); + doc["temperature"] = temp_hum_val[1]; + ``` + +1. O valor da temperatura não precisa ser lido com muita frequência - ele não mudará muito em um curto espaço de tempo, então defina o `delay` na função `loop` para 10 minutos: + + ```cpp + delay(10 * 60 * 1000); + ``` + + > 💁 A função `delay` leva o tempo em milissegundos, então para facilitar a leitura o valor é passado como resultado de um cálculo. 1.000ms em um segundo, 60s em um minuto, então 10 x (60s em um minuto) x (1000ms em um segundo) dá um atraso de 10 minutos. + +1. Faça o upload para o seu Terminal Wio e use o monitor serial para ver a temperatura sendo enviada para o corretor MQTT. + + ```output + --- 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 --- + Connecting to WiFi.. + Connected! + Attempting MQTT connection...connected + Sending telemetry {"temperature":25} + Sending telemetry {"temperature":25} + ``` + +> 💁 Você pode encontrar esse código na pasta [code-publish-temperature/wio-terminal](../code-publish-temperature/wio-terminal). + +😀 Você publicou com sucesso a temperatura como telemetria do seu dispositivo. diff --git a/2-farm/lessons/1-predict-plant-growth/translations/wio-terminal-temp.pt.md b/2-farm/lessons/1-predict-plant-growth/translations/wio-terminal-temp.pt.md new file mode 100644 index 00000000..bbb090da --- /dev/null +++ b/2-farm/lessons/1-predict-plant-growth/translations/wio-terminal-temp.pt.md @@ -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. + +![Um sensor de temperatura Grove](../../../../images/grove-dht11.png) + +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. + +![O sensor de temperatura Grove conectado ao soquete do lado direito](../../../../images/wio-temperature-sensor.png) + +## 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 ` existente: + + ```cpp + #include + #include + ``` + + 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! diff --git a/2-farm/lessons/4-migrate-your-plant-to-the-cloud/translations/wio-terminal-connect-hub.pt.md b/2-farm/lessons/4-migrate-your-plant-to-the-cloud/translations/wio-terminal-connect-hub.pt.md new file mode 100644 index 00000000..d976d458 --- /dev/null +++ b/2-farm/lessons/4-migrate-your-plant-to-the-cloud/translations/wio-terminal-connect-hub.pt.md @@ -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 = ""; + ``` + + Substitua `` 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 + #include "samd/NTPClientAz.h" + #include + + 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 + #include + #include + #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! diff --git a/2-farm/translations/README.pt.md b/2-farm/translations/README.pt.md new file mode 100644 index 00000000..b54b296a --- /dev/null +++ b/2-farm/translations/README.pt.md @@ -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) diff --git a/quiz-app/src/assets/translations/pt.json b/quiz-app/src/assets/translations/pt.json new file mode 100644 index 00000000..055f10be --- /dev/null +++ b/quiz-app/src/assets/translations/pt.json @@ -0,0 +1,2461 @@ +[ + { + "title": "IoT Development for Beginners: Quizzes", + "complete": "Congratulations, you completed the quiz!", + "error": "Sorry, try again", + "quizzes": [ + { + "id": 1, + "title": "Lesson 1 - Introduction to IoT: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "The I in IoT stands for:", + "answerOptions": [ + { + "answerText": "Internet", + "isCorrect": "true" + }, + { + "answerText": "Iridium", + "isCorrect": "false" + }, + { + "answerText": "Ironing", + "isCorrect": "false" + } + ] + }, + { + "questionText": "What's the estimated number of IoT devices in use by the end of 2020?", + "answerOptions": [ + { + "answerText": "30", + "isCorrect": "false" + }, + { + "answerText": "30 million", + "isCorrect": "false" + }, + { + "answerText": "30 billion", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Smartphones are IoT devices", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 2, + "title": "Lesson 1 - Introduction to IoT: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "IoT devices need to be connected to the Internet at all time", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "IoT devices are always secure", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "AI can be run on low powered IoT devices", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 3, + "title": "Lesson 2 - A deeper dive into IoT: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "The T in IoT stands for:", + "answerOptions": [ + { + "answerText": "Transistors", + "isCorrect": "false" + }, + { + "answerText": "Things", + "isCorrect": "true" + }, + { + "answerText": "Turkeys", + "isCorrect": "false" + } + ] + }, + { + "questionText": "IoT devices gather information from the world around them using:", + "answerOptions": [ + { + "answerText": "Sensors", + "isCorrect": "true" + }, + { + "answerText": "Actuators", + "isCorrect": "false" + }, + { + "answerText": "Carrier pigeons", + "isCorrect": "false" + } + ] + }, + { + "questionText": "IoT devices draw more power than the average desktop or laptop computer", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 4, + "title": "Lesson 2 - A deeper dive into IoT: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "The three steps in a CPU instruction cycle are:", + "answerOptions": [ + { + "answerText": "Decode, Execute, Fetch", + "isCorrect": "false" + }, + { + "answerText": "Fetch, Decode, Execute", + "isCorrect": "true" + }, + { + "answerText": "Stop, Collaborate, Listen", + "isCorrect": "false" + } + ] + }, + { + "questionText": "What operating system do Raspberry Pis run?", + "answerOptions": [ + { + "answerText": "They don't run an OS", + "isCorrect": "false" + }, + { + "answerText": "Windows 95", + "isCorrect": "false" + }, + { + "answerText": "Raspberry Pi OS", + "isCorrect": "true" + } + ] + }, + { + "questionText": "IoT devices typically run faster and have more memory than the average desktop or laptop computer", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 5, + "title": "Lesson 3 - Interact with the physical world with sensors and actuators: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "An LED is a sensor:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Sensors are used to:", + "answerOptions": [ + { + "answerText": "Gather data from the physical world.", + "isCorrect": "true" + }, + { + "answerText": "Control the physical world.", + "isCorrect": "false" + }, + { + "answerText": "Only monitor temperature.", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Actuators are use to:", + "answerOptions": [ + { + "answerText": "Gather data from the physical world.", + "isCorrect": "false" + }, + { + "answerText": "Control the physical world.", + "isCorrect": "true" + }, + { + "answerText": "To calculate insurance risks.", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 6, + "title": "Lesson 3 - Interact with the physical world with sensors and actuators: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "Digital sensors send data as:", + "answerOptions": [ + { + "answerText": "Voltage ranges", + "isCorrect": "false" + }, + { + "answerText": "High and low voltages only", + "isCorrect": "true" + }, + { + "answerText": "Emails", + "isCorrect": "false" + } + ] + }, + { + "questionText": "What digital signal is sent when a button is pressed?", + "answerOptions": [ + { + "answerText": "0", + "isCorrect": "false" + }, + { + "answerText": "1", + "isCorrect": "true" + } + ] + }, + { + "questionText": "You can control analog actuators from a digital device using pulse-width modulation", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 7, + "title": "Lesson 4 - Connect your device to the Internet: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "IoT devices always need to be connected to the Internet to work:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "IoT devices always communicate over HTTP, the same as web apps and other web APIs:", + "answerOptions": [ + { + "answerText": "False", + "isCorrect": "true" + }, + { + "answerText": "True", + "isCorrect": "false" + } + ] + }, + { + "questionText": "IoT devices rely on the cloud for all their decision making:", + "answerOptions": [ + { + "answerText": "False", + "isCorrect": "true" + }, + { + "answerText": "True", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 8, + "title": "Lesson 4 - Connect your device to the Internet: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "Data gathered from sensors and sent to the cloud is called:", + "answerOptions": [ + { + "answerText": "Telemetry", + "isCorrect": "true" + }, + { + "answerText": "Commands", + "isCorrect": "false" + }, + { + "answerText": "Measurements", + "isCorrect": "false" + } + ] + }, + { + "questionText": "What should happen to a command if the IoT device is offline:", + "answerOptions": [ + { + "answerText": "It should always be resent when the device is back online", + "isCorrect": "false" + }, + { + "answerText": "It should never be resent when the device is back online", + "isCorrect": "false" + }, + { + "answerText": "It depends on the command, the device and the requirements of the IoT app", + "isCorrect": "true" + } + ] + }, + { + "questionText": "MQTT, or Message Queueing Telemetry Transport, has message queues:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 9, + "title": "Lesson 5 - Predict plant growth: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "IoT devices can be used to support agriculture", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Plant needs include: (pick the best answer)", + "answerOptions": [ + { + "answerText": "Carbon dioxide, water, nutrients", + "isCorrect": "false" + }, + { + "answerText": "Carbon dioxide, water, nutrients, light", + "isCorrect": "false" + }, + { + "answerText": "Carbon dioxide, water, nutrients, light, warmth", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Sensors are too expensive for farmers in developed nations to use:", + "answerOptions": [ + { + "answerText": "False", + "isCorrect": "true" + }, + { + "answerText": "True", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 10, + "title": "Lesson 5 - Predict plant growth: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "Plant growth is dependant on temperature", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "The temperatures to consider for plant growth are:", + "answerOptions": [ + { + "answerText": "Minimum, maximum", + "isCorrect": "false" + }, + { + "answerText": "Base, optimal, maximum", + "isCorrect": "true" + }, + { + "answerText": "Maximum only", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Growing Degree Days are calculated using which formula:", + "answerOptions": [ + { + "answerText": "(day max + day min) - plant base", + "isCorrect": "false" + }, + { + "answerText": "((day max + day min) / 2) - plant base", + "isCorrect": "true" + }, + { + "answerText": "((day min + plant base) / 2)", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 11, + "title": "Lesson 6 - Detect soil moisture: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "IoT devices can be used to detect ambient properties like soil moisture", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Which of these can cause problems for plant growth (pick one)?", + "answerOptions": [ + { + "answerText": "Too little water", + "isCorrect": "false" + }, + { + "answerText": "Too much water", + "isCorrect": "false" + }, + { + "answerText": "Too little or too much water", + "isCorrect": "true" + } + ] + }, + { + "questionText": "All sensors are provided pre-calibrated for standard units:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 12, + "title": "Lesson 6 - Detect soil moisture: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "When measuring soil moisture, one difference between resistive and capacitive moisture sensors is:", + "answerOptions": [ + { + "answerText": "As moisture levels go up the voltage goes up for resistive sensors and down for capacitive sensors", + "isCorrect": "true" + }, + { + "answerText": "As moisture levels go up the voltage goes down for resistive sensors and up for capacitive sensors", + "isCorrect": "false" + }, + { + "answerText": "As moisture levels go up the voltage goes up for both resistive and capacitive sensors", + "isCorrect": "false" + } + ] + }, + { + "questionText": "The SPI protocol supports:", + "answerOptions": [ + { + "answerText": "Only one controller and only one peripheral", + "isCorrect": "false" + }, + { + "answerText": "Only one controller and multiple peripherals", + "isCorrect": "true" + }, + { + "answerText": "Multiple controllers and multiple peripherals", + "isCorrect": "false" + } + ] + }, + { + "questionText": "The I2C protocol supports:", + "answerOptions": [ + { + "answerText": "Only one controller and only one peripheral", + "isCorrect": "false" + }, + { + "answerText": "Only one controller and multiple peripherals", + "isCorrect": "false" + }, + { + "answerText": "Multiple controllers and multiple peripherals", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 13, + "title": "Lesson 7 - Automated plant watering: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "IoT devices are powerful enough to control water pumps", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Actuators can be used to control power to additional devices", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Sensors detect changes from actuators immediately", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 14, + "title": "Lesson 7 - Automated plant watering: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "A relay is what type of switch:", + "answerOptions": [ + { + "answerText": "Electrical", + "isCorrect": "false" + }, + { + "answerText": "Electromechanical", + "isCorrect": "true" + }, + { + "answerText": "Mechanical", + "isCorrect": "false" + } + ] + }, + { + "questionText": "A relay allows:", + "answerOptions": [ + { + "answerText": "A low power device to control a higher power device", + "isCorrect": "true" + }, + { + "answerText": "A high power device to control a low power device", + "isCorrect": "false" + }, + { + "answerText": "Runners to run a race passing a baton between them", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Actuators should always respond instantly to sensor readings:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 15, + "title": "Lesson 8 - Migrate your plant to the cloud: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "A public MQTT broker is fine to use for a commercial IoT project", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Cloud computing allow you to:", + "answerOptions": [ + { + "answerText": "Only rent computers", + "isCorrect": "false" + }, + { + "answerText": "Rent computers and application platforms only", + "isCorrect": "false" + }, + { + "answerText": "Rent computers, application platforms, software, serverless platforms and other services", + "isCorrect": "true" + } + ] + }, + { + "questionText": "There are multiple cloud vendors with data centers in many different countries across 6 continents", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 16, + "title": "Lesson 8 - Migrate your plant to the cloud: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "To request control of an actuator and get a response from an IoT device, app code can use a:", + "answerOptions": [ + { + "answerText": "Device to cloud message", + "isCorrect": "false" + }, + { + "answerText": "Device twin", + "isCorrect": "false" + }, + { + "answerText": "Direct method request", + "isCorrect": "true" + } + ] + }, + { + "questionText": "IoT Hub lets any device connect without any security:", + "answerOptions": [ + { + "answerText": "False", + "isCorrect": "true" + }, + { + "answerText": "True", + "isCorrect": "false" + } + ] + }, + { + "questionText": "IoT Hub names must be unique:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 17, + "title": "Lesson 9 - Migrate your application logic to the cloud: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "You can use Serverless code to respond to IoT events", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "When you send IoT events to IoT Hub:", + "answerOptions": [ + { + "answerText": "Only one service can read events off the IoT Hub", + "isCorrect": "false" + }, + { + "answerText": "Any number of services can read events off the IoT Hub", + "isCorrect": "true" + }, + { + "answerText": "Services cannot read events from IoT Hub, they have to connect to the device directly", + "isCorrect": "false" + } + ] + }, + { + "questionText": "When reading events off IoT hub, you can only do so using code that runs in the cloud", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 18, + "title": "Lesson 9 - Migrate your application logic to the cloud: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "Azure Functions can be run and debugged locally:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Serverless code can only be written in JavaScript and COBOL:", + "answerOptions": [ + { + "answerText": "False", + "isCorrect": "true" + }, + { + "answerText": "True", + "isCorrect": "false" + } + ] + }, + { + "questionText": "When deploying a Functions App to the cloud, you need to create and deploy:", + "answerOptions": [ + { + "answerText": "A Functions App only", + "isCorrect": "false" + }, + { + "answerText": "A Functions App and a Storage Account only", + "isCorrect": "false" + }, + { + "answerText": "A Functions App, a Storage Account, and Application Settings", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 19, + "title": "Lesson 10 - Keep your plant secure: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "IoT devices are always secure", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "There are no documented cases of hackers using an IoT device to hack into a network:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "You can share your IoT device connection string with anyone", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 20, + "title": "Lesson 10 - Keep your plant secure: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "Symmetric key encryption compares to asymmetric key encryption in which ways:", + "answerOptions": [ + { + "answerText": "Symmetric key encryption is slower than asymmetric", + "isCorrect": "false" + }, + { + "answerText": "Symmetric key encryption is more secure than asymmetric", + "isCorrect": "false" + }, + { + "answerText": "Symmetric key encryption is faster than asymmetric, but less secure", + "isCorrect": "true" + }, + { + "answerText": "Symmetric key encryption is slower than asymmetric, but more secure", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Self-signed X.509 certificates are ideal for a production environment", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "X.509 certificates:", + "answerOptions": [ + { + "answerText": "Should never be shared between IoT devices", + "isCorrect": "false" + }, + { + "answerText": "Can be shared between devices", + "isCorrect": "true" + }, + { + "answerText": "Should be kept secure and never used by any devices", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 21, + "title": "Lesson 11 - Location tracking: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "Your location can be defined using", + "answerOptions": [ + { + "answerText": "Latitude only", + "isCorrect": "false" + }, + { + "answerText": "Longitude only", + "isCorrect": "false" + }, + { + "answerText": "Latitude and Longitude", + "isCorrect": "true" + } + ] + }, + { + "questionText": "The types of sensors that can track your location are called:", + "answerOptions": [ + { + "answerText": "GPS", + "isCorrect": "true" + }, + { + "answerText": "PGP", + "isCorrect": "false" + }, + { + "answerText": "GIF", + "isCorrect": "false" + } + ] + }, + { + "questionText": "There is no value in tracking vehicle locations", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 22, + "title": "Lesson 11 - Location tracking: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "GPS data is sent from sensors using:", + "answerOptions": [ + { + "answerText": "Latitude and Longitude coordinates", + "isCorrect": "false" + }, + { + "answerText": "Addresses", + "isCorrect": "false" + }, + { + "answerText": "NMEA sentences", + "isCorrect": "true" + } + ] + }, + { + "questionText": "To get a good GPS fix you need to receive signals from at least how many satellites", + "answerOptions": [ + { + "answerText": "1", + "isCorrect": "false" + }, + { + "answerText": "2", + "isCorrect": "false" + }, + { + "answerText": "3", + "isCorrect": "true" + } + ] + }, + { + "questionText": "GPS sensors send data over:", + "answerOptions": [ + { + "answerText": "SPI", + "isCorrect": "false" + }, + { + "answerText": "UART", + "isCorrect": "true" + }, + { + "answerText": "Email", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 23, + "title": "Lesson 12 - Store location data: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "IoT data is stored by IoT Hub", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Data can be divided into the following two types", + "answerOptions": [ + { + "answerText": "Blob and table", + "isCorrect": "false" + }, + { + "answerText": "Structured and unstructured", + "isCorrect": "true" + }, + { + "answerText": "Red and blue", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Serverless code can be used to write IoT data to a database", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 24, + "title": "Lesson 12 - Store location data: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "IoT data that needs to be processed immediately is on which path:", + "answerOptions": [ + { + "answerText": "Hot", + "isCorrect": "true" + }, + { + "answerText": "Warm", + "isCorrect": "false" + }, + { + "answerText": "Cold", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Azure storage has the following storage types:", + "answerOptions": [ + { + "answerText": "Boxes, tubs, bins", + "isCorrect": "false" + }, + { + "answerText": "Blob, table, queue and file", + "isCorrect": "true" + }, + { + "answerText": "Hot, warm, cold", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Azure Functions can be bound to database to write return values to the database", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 25, + "title": "Lesson 13 - Visualize location data: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "Very large tables of data are an easy way to quickly look up data", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "GPS data can be visualized on maps", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "On maps of large areas, the same distance drawn on the map represents the same distance on the real world no matter where on the map the measurement is taken", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 26, + "title": "Lesson 13 - Visualize location data: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "The service to draw maps on a web page is called:", + "answerOptions": [ + { + "answerText": "Azure Maps", + "isCorrect": "true" + }, + { + "answerText": "Azure Atlas", + "isCorrect": "false" + }, + { + "answerText": "Azure World VIsualizer", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Azure maps plots data using:", + "answerOptions": [ + { + "answerText": "GeoJSON", + "isCorrect": "true" + }, + { + "answerText": "Lists of latitude and longitude", + "isCorrect": "false" + }, + { + "answerText": "Lists of addresses", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Blobs can be retrieved via a URL", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 27, + "title": "Lesson 14 - Geofences: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "GPS coordinates can be used to check if something is in a defined area", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "GPS is incredibly accurate so can indicate with precision of less than 1M when a device enters a given area", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Geofences are useful when tracking vehicles to:", + "answerOptions": [ + { + "answerText": "Determine when a vehicle enters a given area only", + "isCorrect": "false" + }, + { + "answerText": "Determine when a vehicle leaves a given area only", + "isCorrect": "false" + }, + { + "answerText": "Determine when a vehicle enters or leaves a given area", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 28, + "title": "Lesson 14 - Geofences: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "To have multiple services pull data from an IoT Hub, you need to create multiple:", + "answerOptions": [ + { + "answerText": "Consumer groups", + "isCorrect": "true" + }, + { + "answerText": "Pipes", + "isCorrect": "false" + }, + { + "answerText": "IoT Hubs", + "isCorrect": "false" + } + ] + }, + { + "questionText": "The default search buffer for a geofence call is:", + "answerOptions": [ + { + "answerText": "5m", + "isCorrect": "false" + }, + { + "answerText": "50m", + "isCorrect": "true" + }, + { + "answerText": "500m", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Points inside the geofence have a distance:", + "answerOptions": [ + { + "answerText": "Less than 0 (a negative value)", + "isCorrect": "true" + }, + { + "answerText": "Greater than 0 (a positive value)", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 29, + "title": "Lesson 15 - Train a fruit quality detector: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "Cameras can be used as IoT sensors", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Fruit can be sorted using cameras", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Images-based AI models are incredibly complex and time consuming to train, requiring hundreds of thousands of images:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 30, + "title": "Lesson 15 - Train a fruit quality detector: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "The technique custom vision uses to train a model with only a few images is called:", + "answerOptions": [ + { + "answerText": "Transformational learning", + "isCorrect": "false" + }, + { + "answerText": "Transaction learning", + "isCorrect": "false" + }, + { + "answerText": "Transfer learning", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Image classifiers can be trained using:", + "answerOptions": [ + { + "answerText": "Only 1 image per tag", + "isCorrect": "false" + }, + { + "answerText": "At least 5 images per tag", + "isCorrect": "true" + }, + { + "answerText": "At least 50 images per tag", + "isCorrect": "false" + } + ] + }, + { + "questionText": "The hardware that allows ML models to be trained quickly, as well as making the graphics on out Xbox look amazing are called:", + "answerOptions": [ + { + "answerText": "PGU", + "isCorrect": "false" + }, + { + "answerText": "GPU", + "isCorrect": "true" + }, + { + "answerText": "PUG", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 31, + "title": "Lesson 16 - Check fruit quality from an IoT device: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "IoT devices are not powerful enough to use cameras:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Camera sensors use film to capture images", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Camera sensors send which type of data", + "answerOptions": [ + { + "answerText": "Digital", + "isCorrect": "true" + }, + { + "answerText": "Analog", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 32, + "title": "Lesson 16 - Check fruit quality from an IoT device: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "A published version of a custom vision model is called an:", + "answerOptions": [ + { + "answerText": "Iteration", + "isCorrect": "true" + }, + { + "answerText": "Instance", + "isCorrect": "false" + }, + { + "answerText": "Iguana", + "isCorrect": "false" + } + ] + }, + { + "questionText": "When images are sent for classification, they then become available to retrain the model:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "You don't need to use images captured from an IoT device to train the model as the cameras are as good quality as phone cameras:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 33, + "title": "Lesson 17 - Run your fruit detector on the edge: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "Edge computing can be more secure than cloud computing.", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Running an ML model on an edge device is less accurate than running an ML model in the cloud.", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Edge devices always need an Internet connection.", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 34, + "title": "Lesson 17 - Run your fruit detector on the edge: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "What kind of format or domain do we need for Custom Vision ML models to properly run on an edge device?", + "answerOptions": [ + { + "answerText": "General", + "isCorrect": "false" + }, + { + "answerText": "Quick Training", + "isCorrect": "false" + }, + { + "answerText": "Standard", + "isCorrect": "false" + }, + { + "answerText": "Compact", + "isCorrect": "true" + }, + { + "answerText": "Food", + "isCorrect": "false" + }, + { + "answerText": "Remote Deployment", + "isCorrect": "false" + } + ] + }, + { + "questionText": "What is a container?", + "answerOptions": [ + { + "answerText": "Self-contained applications that hold ML models.", + "isCorrect": "false" + }, + { + "answerText": "Self-contained applications that run in isolation from other programs.", + "isCorrect": "true" + }, + { + "answerText": "Self-contained applications that run programs only on edge devices.", + "isCorrect": "false" + }, + { + "answerText": "self-contained applications that handle communication between the cloud and edge devices.", + "isCorrect": "false" + } + ] + }, + { + "questionText": "How do you do Custom Vision model retraining for ML models deployed on edge devices?", + "answerOptions": [ + { + "answerText": "Take images on the edge device, save to the edge device, and point the ML model to the new image folder.", + "isCorrect": "false" + }, + { + "answerText": "Upload images from the edge device to the cloud, retrain the model in Custom Vision, then re-deploy onto the edge device.", + "isCorrect": "true" + }, + { + "answerText": "Take images on the edge device and check the prediction output.", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 35, + "title": "Lesson 18 - Trigger fruit quality detection from a sensor: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "Which part of your IoT application gathers data?", + "answerOptions": [ + { + "answerText": "Things", + "isCorrect": "true" + }, + { + "answerText": "Cloud services", + "isCorrect": "false" + }, + { + "answerText": "Edge devices", + "isCorrect": "false" + } + ] + }, + { + "questionText": "The only outputs of an IoT application are actuators.", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Things don't need to connect directly to IoT Hub, they can use edge devices as gateways.", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 36, + "title": "Lesson 18 - Trigger fruit quality detection from a sensor: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "The three components of architecting an IoT application are", + "answerOptions": [ + { + "answerText": "Things, Insights, Actions", + "isCorrect": "true" + }, + { + "answerText": "Things, Internet, Databases", + "isCorrect": "false" + }, + { + "answerText": "AI, Blockchain, FizzBuzzers", + "isCorrect": "false" + } + ] + }, + { + "questionText": "The component that communicates between the things and the components that create insights is:", + "answerOptions": [ + { + "answerText": "Azure Functions", + "isCorrect": "false" + }, + { + "answerText": "IoT Hub", + "isCorrect": "true" + }, + { + "answerText": "Azure Maps", + "isCorrect": "false" + } + ] + }, + { + "questionText": "How do time of flight proximity sensors work?", + "answerOptions": [ + { + "answerText": "They send laser beams and time how long till they bounce off an object", + "isCorrect": "true" + }, + { + "answerText": "They use sound and measure how long till the sound bounces off an object", + "isCorrect": "false" + }, + { + "answerText": "They use very large rulers", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 37, + "title": "Lesson 19 - Train a stock detector: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "AI models cannot be used to count objects?", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "IoT and AI can be used in retail for:", + "answerOptions": [ + { + "answerText": "Stock checking only", + "isCorrect": "false" + }, + { + "answerText": "A wide range of uses including stock checking, monitoring for mask where where required, tracking footfall, automated billing", + "isCorrect": "true" + }, + { + "answerText": "IoT and AI cannot be used in retail", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Object detection involves:", + "answerOptions": [ + { + "answerText": "Detecting objects in an image and tracking their location and probability", + "isCorrect": "true" + }, + { + "answerText": "Counting objects in an image only", + "isCorrect": "false" + }, + { + "answerText": "Classifying images", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 38, + "title": "Lesson 19 - Train a stock detector: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "Object detectors only return one result no matter how many objects are detected", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "What is the best domain to use in Custom Vision for stock counting", + "answerOptions": [ + { + "answerText": "General", + "isCorrect": "false" + }, + { + "answerText": "Food", + "isCorrect": "false" + }, + { + "answerText": "Products on shelves", + "isCorrect": "true" + } + ] + }, + { + "questionText": "At least how many images do you need to train an object detector?", + "answerOptions": [ + { + "answerText": "1", + "isCorrect": "false" + }, + { + "answerText": "15", + "isCorrect": "true" + }, + { + "answerText": "100", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 39, + "title": "Lesson 20 - Check stock from an IoT device: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "IoT devices are not powerful enough to use object detectors", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Object detectors give you:", + "answerOptions": [ + { + "answerText": "The count of objects detected", + "isCorrect": "false" + }, + { + "answerText": "The count and location of objects detected", + "isCorrect": "false" + }, + { + "answerText": "The count, location and probability of objects detected", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Object detectors can be used to detect where missing stock should be to allow robots to automatically stock shelves", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 40, + "title": "Lesson 20 - Check stock from an IoT device: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "To count stock you only need to consider the count of objects detected by the object detector", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Bounding boxes use:", + "answerOptions": [ + { + "answerText": "Percentage based coordinates", + "isCorrect": "true" + }, + { + "answerText": "Pixel based coordinates", + "isCorrect": "false" + }, + { + "answerText": "Centimeter based coordinates", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Can detected objects overlap?", + "answerOptions": [ + { + "answerText": "Yes", + "isCorrect": "true" + }, + { + "answerText": "No", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 41, + "title": "Lesson 21 - Recognize speech with an IoT device: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "IoT devices can be used to recognize speech:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Voice assistants should send all the audio they hear to the cloud for processing:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "To recognize speech, IoT devices need large microphones:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 42, + "title": "Lesson 21 - Recognize speech with an IoT device: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "Microphones are what type of sensor?", + "answerOptions": [ + { + "answerText": "Digital", + "isCorrect": "false" + }, + { + "answerText": "Analog", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Sound waves are converted to digital signals using:", + "answerOptions": [ + { + "answerText": "Pulse Code Modulation", + "isCorrect": "true" + }, + { + "answerText": "Pure Code Multiplication", + "isCorrect": "false" + }, + { + "answerText": "Pulse Width Maximization", + "isCorrect": "false" + } + ] + }, + { + "questionText": "1 second of 16-bit audio sampled at 16KHz is how large?", + "answerOptions": [ + { + "answerText": "1KB", + "isCorrect": "false" + }, + { + "answerText": "16KB", + "isCorrect": "false" + }, + { + "answerText": "32KB", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 43, + "title": "Lesson 22 - Understand language: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "Language understanding involves looking for fixed words:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Language understanding involves:", + "answerOptions": [ + { + "answerText": "Looking at the individual words in a sentence and trying to get the meaning", + "isCorrect": "false" + }, + { + "answerText": "Finding pre-defined sentences and using those to get the meaning", + "isCorrect": "false" + }, + { + "answerText": "Looking at the whole sentence and trying to get the meaning using the context of the words", + "isCorrect": "true" + } + ] + }, + { + "questionText": "Cloud providers have AI services that can understand language:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 44, + "title": "Lesson 22 - Understand language: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "Sentences are understood by being broken down into:", + "answerOptions": [ + { + "answerText": "Ideas and explanations", + "isCorrect": "false" + }, + { + "answerText": "Intents and entities", + "isCorrect": "true" + }, + { + "answerText": "Imps and elves", + "isCorrect": "false" + } + ] + }, + { + "questionText": "The Microsoft service for language understanding is called:", + "answerOptions": [ + { + "answerText": "LUIS", + "isCorrect": "true" + }, + { + "answerText": "Luigi", + "isCorrect": "false" + }, + { + "answerText": "Jarvis", + "isCorrect": "false" + } + ] + }, + { + "questionText": "In the sentence 'set a 3 minute timer' the:", + "answerOptions": [ + { + "answerText": "The intent is 3 minutes and the entity is a timer", + "isCorrect": "false" + }, + { + "answerText": "The intent is minutes, and the entity is 3 timers", + "isCorrect": "false" + }, + { + "answerText": "The intent is set a timer and the entity is 3 minutes", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 45, + "title": "Lesson 23 - Set a timer and provide spoken feedback: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "Speech generated by AI models sounds monotonous and robotic", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "AI models can only create speech in American English:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "AI models would convert 1234 into which spoken phrase:", + "answerOptions": [ + { + "answerText": "One two three four", + "isCorrect": "false" + }, + { + "answerText": "One thousand two hundred and thirty four", + "isCorrect": "false" + }, + { + "answerText": "It can be 'one two three four' or 'one thousand two hundred and thirty four' depending on the context", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 46, + "title": "Lesson 23 - Set a timer and provide spoken feedback: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "The three parts of speech generation are:", + "answerOptions": [ + { + "answerText": "Text analysis, understanding analysis, sound generation", + "isCorrect": "false" + }, + { + "answerText": "Text analysis, linguistic analysis, wave form generation", + "isCorrect": "true" + }, + { + "answerText": "Word analysis, audio production", + "isCorrect": "false" + } + ] + }, + { + "questionText": "Can speech generation models be trained to sound like existing people:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "The markup language used to encode speech is called:", + "answerOptions": [ + { + "answerText": "SSML", + "isCorrect": "true" + }, + { + "answerText": "MSSL", + "isCorrect": "false" + }, + { + "answerText": "SpeechXML", + "isCorrect": "false" + } + ] + } + ] + }, + { + "id": 47, + "title": "Lesson 24 - Support multiple languages: Pre-Lecture Quiz", + "quiz": [ + { + "questionText": "Language understanding only understands English:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + }, + { + "questionText": "AI speech to text models understand multiple languages:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "true" + }, + { + "answerText": "False", + "isCorrect": "false" + } + ] + }, + { + "questionText": "AI translation involves swapping individual words for their translated version:", + "answerOptions": [ + { + "answerText": "True", + "isCorrect": "false" + }, + { + "answerText": "False", + "isCorrect": "true" + } + ] + } + ] + }, + { + "id": 48, + "title": "Lesson 24 - Support multiple languages: Post-Lecture Quiz", + "quiz": [ + { + "questionText": "Machine translation has been researched for nearly:", + "answerOptions": [ + { + "answerText": "70 years", + "isCorrect": "true" + }, + { + "answerText": "17 years", + "isCorrect": "false" + }, + { + "answerText": "7 years", + "isCorrect": "false" + } + ] + }, + { + "questionText": "AI language translators are called:", + "answerOptions": [ + { + "answerText": "Noddy translators", + "isCorrect": "false" + }, + { + "answerText": "Neural translators", + "isCorrect": "true" + }, + { + "answerText": "Nothing - AI cannot be used for translation", + "isCorrect": "false" + } + ] + }, + { + "questionText": "What alien languages does the Microsoft translator support:", + "answerOptions": [ + { + "answerText": "Na'vi", + "isCorrect": "false" + }, + { + "answerText": "Alienese", + "isCorrect": "false" + }, + { + "answerText": "Klingon", + "isCorrect": "true" + } + ] + } + ] + } + ] + } +] \ No newline at end of file diff --git a/translations/clean-up.pt.md b/translations/clean-up.pt.md new file mode 100644 index 00000000..13d96922 --- /dev/null +++ b/translations/clean-up.pt.md @@ -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 +``` + +Substitua `` 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) \ No newline at end of file From 0fa0e42aa4954b76b9925d0bc7513fc8351bebe1 Mon Sep 17 00:00:00 2001 From: weslleylmurdock Date: Sat, 8 Oct 2022 06:51:58 -0300 Subject: [PATCH 2/2] renamed file --- ...r-temp-publish.md => single-board-computer-temp-publish.pt.md} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 2-farm/lessons/1-predict-plant-growth/translations/{single-board-computer-temp-publish.md => single-board-computer-temp-publish.pt.md} (100%) diff --git a/2-farm/lessons/1-predict-plant-growth/translations/single-board-computer-temp-publish.md b/2-farm/lessons/1-predict-plant-growth/translations/single-board-computer-temp-publish.pt.md similarity index 100% rename from 2-farm/lessons/1-predict-plant-growth/translations/single-board-computer-temp-publish.md rename to 2-farm/lessons/1-predict-plant-growth/translations/single-board-computer-temp-publish.pt.md