[PT] Portuguese Brazilian translation of 2 - farm

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

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 |

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!

2-farm/lessons/1-predict-plant-growth/translations/single-board-computer-temp-publish.pt.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.

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!