Translation of Getting Started Lesson 1 to portuguese (#243)
* Translation of Getting Started README.md to portuguese * Translation of Introduction to IoT README.md to portuguese * Translation of Introduction to IoT wio-terminal.md to portuguese * Update of some terms of the README.pt.md * Translation of Introduction to IoT assignmentl.md to portuguese * Translation of Introduction to IoT virtual-device.md to portuguese * Translation of Introduction to IoT pi.md to portuguese * Updating the translation of the device name Co-authored-by: Jim Bennett <jim.bennett@microsoft.com>pull/270/head
Leonardo Nascimento
3 years ago
committed by
GitHub
parent
475d6f4d2d
commit
06598b2021
@ -0,0 +1,13 @@
|
||||
# Investigue um projeto de IoT
|
||||
|
||||
## Instruções
|
||||
|
||||
Existem muitos projetos de IoT de grande e pequena escala sendo implementados globalmente, de fazendas inteligentes a cidades inteligentes, em monitoramento de saúde, transporte e para o uso de espaços públicos.
|
||||
|
||||
Pesquise na web por detalhes de um projeto do seu interesse, de preferência um perto de onde você mora. Explique as vantagens e desvantagens do projeto, por exemplo, quais os benefícios dele, quaisquer problemas que ele causa e como a privacidade é levada em consideração.
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Precisa Melhorar |
|
||||
| --------- | -------- | -------- | ---------------- |
|
||||
| Explique as vantagens e desvantagens | Deu uma explicação clara das vantagens e desvantagens do projeto | Deu uma breve explicação sobre as vantagens e desvantagens | Não explicou as vantagens ou desvantagens |
|
||||
@ -0,0 +1,245 @@
|
||||
# Raspberry Pi
|
||||
|
||||
O [Raspberry Pi](https://raspberrypi.org) é um computador de placa única. Você pode adicionar sensores e atuadores usando uma ampla variedade de dispositivos e ecossistemas, e para essas lições, usando um ecossistema de hardware chamado [Grove](https://www.seeedstudio.com/category/Grove-c-1003.html). Você codificará seu Pi e acessará os sensores Grove usando Python.
|
||||
|
||||
|
||||
|
||||
## Configuração
|
||||
|
||||
Se você estiver usando um Raspberry Pi como seu hardware IoT, você tem duas opções - você pode trabalhar em todas essas lições e codificar diretamente no Pi ou pode se conectar remotamente a um Pi 'headless' e codificar de seu computador.
|
||||
|
||||
Antes de começar, você também precisa conectar o Grove Base Hat ao seu Pi.
|
||||
|
||||
### Tarefa - configuração
|
||||
|
||||
Instale o Grove Base Hat no seu Pi e configure o Pi
|
||||
|
||||
1. Conecte o Grove Base Hat ao seu Pi. O soquete no Grove Base Hat se encaixa em todos os pinos de GPIO no Pi, deslizando para baixo sobre os pinos para que se assente firmemente na base. Ele fica sobre o Pi, cobrindo-o.
|
||||
|
||||
|
||||
|
||||
1. Decida como você deseja programar seu Pi e vá para a seção relevante abaixo:
|
||||
|
||||
* [Trabalhe diretamente no seu Pi](#trabalhe-diretamente-no-seu-pi)
|
||||
* [Acesso remoto para codificar o Pi](#acesso-remoto-para-codificar-o-pi)
|
||||
|
||||
### Trabalhe diretamente no seu Pi
|
||||
|
||||
Se você quiser trabalhar diretamente no seu Pi, pode usar a versão desktop do Raspberry Pi OS e instalar todas as ferramentas de que precisa.
|
||||
|
||||
#### Tarefa - trabalhe diretamente no seu Pi
|
||||
|
||||
Configure seu Pi para desenvolvimento.
|
||||
|
||||
1. Siga as instruções no [guia de configuração do Raspberry Pi](https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up) para configurar seu Pi, conecte-o a um teclado/mouse/monitor, conecte-o à sua rede WiFi ou ethernet e atualize o software. O sistema operacional que você deseja instalar é o **Raspberry Pi OS (32 bits)**, ele é marcado como o sistema operacional recomendado ao usar o Raspberry Pi Imager para criar a imagem do seu cartão SD.
|
||||
|
||||
Para programar o Pi usando os sensores e atuadores Grove, você precisará instalar um editor para permitir que você escreva o código do dispositivo e várias bibliotecas e ferramentas que interagem com o hardware Grove.
|
||||
|
||||
1. Assim que seu Pi for reiniciado, inicie o Terminal clicando no ícone **Terminal** na barra de menu superior ou escolha *Menu -> Acessórios -> Terminal*
|
||||
|
||||
1. Execute o seguinte comando para garantir que o sistema operacional e o software instalado estejam atualizados:
|
||||
|
||||
```sh
|
||||
sudo apt update && sudo apt full-upgrade --yes
|
||||
```
|
||||
|
||||
1. Execute o seguinte comando para instalar todas as bibliotecas necessárias para o hardware Grove:
|
||||
|
||||
```sh
|
||||
curl -sL https://github.com/Seeed-Studio/grove.py/raw/master/install.sh | sudo bash -s -
|
||||
```
|
||||
|
||||
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, em seguida, usar esse pacote em seu código. Este script de instalação do Grove instalará os pacotes pip que você usará para trabalhar com o hardware Grove a partir do Python.
|
||||
|
||||
1. Reinicialize o Pi usando o menu ou executando o seguinte comando no Terminal:
|
||||
|
||||
```sh
|
||||
sudo reboot
|
||||
```
|
||||
|
||||
1. Após a reinicialização do Pi, reinicie o Terminal e execute o seguinte comando para instalar o [Visual Studio Code (VS Code)](https://code.visualstudio.com?WT.mc_id=academic-17441-jabenn) - este é o editor que você usará para escrever o código do seu dispositivo em Python.
|
||||
|
||||
```sh
|
||||
sudo apt install code
|
||||
```
|
||||
|
||||
Depois de instalado, o VS Code estará disponível no menu superior.
|
||||
|
||||
> 💁 Você está livre para usar qualquer IDE de Python ou editor para essas lições se tiver uma ferramenta preferida, mas as lições darão instruções baseadas no uso do VS Code.
|
||||
|
||||
1. Instale o Pylance. Esta é uma extensão para VS Code que fornece suporte à linguagem Python. Consulte a [documentação da extensão Pylance](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance&WT.mc_id=academic-17441-jabenn) para obter instruções sobre como instalar esta extensão no VS Code.
|
||||
|
||||
### Acesso remoto para codificar o Pi
|
||||
|
||||
Em vez de codificar diretamente no Pi, ele pode rodar 'headless', quando não está conectado a um teclado/mouse/monitor, e assim configurar e codificar nele a partir do seu computador, usando o Visual Studio Code.
|
||||
|
||||
#### Configure o Pi OS
|
||||
|
||||
Para codificar remotamente, o Pi OS precisa ser instalado em um cartão SD.
|
||||
|
||||
##### Tarefa - configurar o Pi OS
|
||||
|
||||
Configure o Pi OS headless.
|
||||
|
||||
1. Baixe o **Raspberry Pi Imager** da [página do software Raspberry Pi OS](https://www.raspberrypi.org/software/) e instale-o
|
||||
|
||||
1. Insira um cartão SD em seu computador, usando um adaptador, se necessário
|
||||
|
||||
1. Inicie o Raspberry Pi Imager
|
||||
|
||||
1. No Raspberry Pi Imager, selecione o botão **CHOOSE OS** e, em seguida, selecione *Raspberry Pi OS (Other)*, seguido por *Raspberry Pi OS Lite (32 bits)*
|
||||
|
||||
|
||||
|
||||
> 💁 Raspberry Pi OS Lite é uma versão do Raspberry Pi OS que não possui a UI para desktop ou ferramentas baseadas em UI. Eles não são necessários para um Pi headless e tornam a instalação menor e o tempo de inicialização mais rápido.
|
||||
|
||||
1. Selecione o botão **CHOOSE STORAGE** e, em seguida, selecione seu cartão SD
|
||||
|
||||
1. Inicie as **Advanced Options** pressionando `Ctrl+Shift+X`. Essas opções permitem alguma pré-configuração do sistema operacional do Raspberry Pi antes que sua imagem seja criada no cartão SD.
|
||||
|
||||
1. Marque a caixa de seleção **Enable SSH** e defina uma senha para o usuário `pi`. Esta é a senha que você usará para fazer login no Pi mais tarde.
|
||||
|
||||
1. Se você está planejando se conectar ao Pi por WiFi, marque a caixa de seleção **Configure WiFi** e insira o SSID e a senha do seu WiFi, bem como selecione o país do seu WiFi. Você não precisa fazer isso se for usar um cabo Ethernet. Certifique-se de que a rede à qual você se conecta é a mesma em que seu computador está.
|
||||
|
||||
1. Marque a caixa de seleção **Set locale settings** e defina seu país e fuso horário
|
||||
|
||||
1. Selecione o botão **SAVE**
|
||||
|
||||
1. Selecione o botão **WRITE** para gravar o sistema operacional no cartão SD. Se estiver usando o macOS, será solicitado que você insira sua senha, pois a ferramenta subjacente que grava imagens de disco precisa de acesso privilegiado.
|
||||
|
||||
O sistema operacional será gravado no cartão SD e, uma vez concluído, o cartão será ejetado pelo sistema operacional e você será notificado. Remova o cartão SD do seu computador, insira-o no Pi e ligue o Pi.
|
||||
|
||||
#### Conecte-se ao Pi
|
||||
|
||||
A próxima etapa é acessar remotamente o Pi. Você pode fazer isso usando `ssh`, que está disponível no macOS, Linux e versões recentes do Windows.
|
||||
|
||||
##### Tarefa - conectar ao Pi
|
||||
|
||||
Acesse remotamente o Pi.
|
||||
|
||||
1. Inicie um Terminal ou Prompt de Comando e digite o seguinte comando para se conectar ao Pi:
|
||||
|
||||
```sh
|
||||
ssh pi@raspberrypi.local
|
||||
```
|
||||
|
||||
Se você estiver no Windows usando uma versão mais antiga que não possui o `ssh` instalado, você pode usar o OpenSSH. Você pode encontrar as instruções de instalação na [documentação de instalação do OpenSSH](https://docs.microsoft.com//windows-server/administration/openssh/openssh_install_firstuse?WT.mc_id=academic-17441-jabenn).
|
||||
|
||||
1. Isso deve se conectar ao seu Pi e pedir a senha.
|
||||
|
||||
Ser capaz de encontrar computadores em sua rede usando `<hostname>.local` é uma adição bastante recente ao Linux e Windows. Se você estiver usando Linux ou Windows e receber algum erro sobre o nome do host não ser encontrado, será necessário instalar software adicional para habilitar o ZeroConf networking (também conhecido pela Apple como Bonjour):
|
||||
|
||||
1. Se você estiver usando Linux, instale o Avahi usando o seguinte comando:
|
||||
|
||||
```sh
|
||||
sudo apt-get install avahi-daemon
|
||||
```
|
||||
|
||||
1. Se você estiver usando o Windows, a maneira mais fácil de ativar o ZeroConf é instalar [Bonjour Print Services para Windows](http://support.apple.com/kb/DL999). Você também pode instalar o [iTunes para Windows](https://www.apple.com/itunes/download/) para obter uma versão mais recente do utilitário (que não está disponível standalone).
|
||||
|
||||
> 💁 Se você não conseguir se conectar usando `raspberrypi.local`, poderá usar o endereço IP do seu Pi. Consulte a [documentação do endereço IP do Raspberry Pi](https://www.raspberrypi.org/documentation/remote-access/ip-address.md) para obter instruções sobre várias maneiras de obter o endereço IP.
|
||||
|
||||
1. Digite a senha que você definiu nas opções avançadas do Raspberry Pi Imager
|
||||
|
||||
#### Configure o software no Pi
|
||||
|
||||
Assim que estiver conectado ao Pi, você precisa garantir que o sistema operacional esteja atualizado e instalar várias bibliotecas e ferramentas que interagem com o hardware Grove.
|
||||
|
||||
##### Tarefa - configurar software no Pi
|
||||
|
||||
Configure o software Pi instalado e instale as bibliotecas Grove.
|
||||
|
||||
1. Na sessão `ssh`, execute o seguinte comando para atualizar e reinicie o Pi:
|
||||
|
||||
```sh
|
||||
sudo apt update && sudo apt full-upgrade --yes && sudo reboot
|
||||
```
|
||||
|
||||
O Pi será atualizado e reiniciado. A sessão `ssh` terminará quando o Pi for reiniciado, então deixe-o por cerca de 30 segundos e reconecte.
|
||||
|
||||
1. A partir da sessão `ssh` reconectada, execute o seguinte comando para instalar todas as bibliotecas necessárias para o hardware Grove:
|
||||
|
||||
```sh
|
||||
curl -sL https://github.com/Seeed-Studio/grove.py/raw/master/install.sh | sudo bash -s -
|
||||
```
|
||||
|
||||
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, em seguida, usar esse pacote em seu código. Este script de instalação do Grove instalará os pacotes pip que você usará para trabalhar com o hardware Grove a partir do Python.
|
||||
|
||||
1. Reinicialize o Pi executando o seguinte comando:
|
||||
|
||||
```sh
|
||||
sudo reboot
|
||||
```
|
||||
|
||||
A sessão `ssh` terminará quando o Pi for reiniciado. Não há necessidade de reconectar.
|
||||
|
||||
#### Configure o VS Code para acesso remoto
|
||||
|
||||
Depois que o Pi estiver configurado, você pode se conectar a ele usando o Visual Studio Code (VS Code) a partir do seu computador - este é um editor de texto para desenvolvedores gratuito que você usará para escrever o código do seu dispositivo em Python.
|
||||
|
||||
##### Tarefa - configurar o VS Code para acesso remoto
|
||||
|
||||
Instale o software necessário e conecte-se remotamente ao seu Pi.
|
||||
|
||||
1. Instale o VS Code em seu computador seguindo a [documentação do VS Code](https://code.visualstudio.com?WT.mc_id=academic-17441-jabenn)
|
||||
|
||||
1. Siga as instruções em [VS Code Remote Development using SSH documentation](https://code.visualstudio.com/docs/remote/ssh?WT.mc_id=academic-17441-jabenn) para instalar os componentes necessários
|
||||
|
||||
1. Seguindo as mesmas instruções, conecte o VS Code ao Pi
|
||||
|
||||
1. Depois de conectado, siga as instruções em [gerenciando extensões](https://code.visualstudio.com/docs/remote/ssh#_managing-extensions?WT.mc_id=academic-17441-jabenn) para instalar a [extensão Pylance](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance&WT.mc_id=academic-17441-jabenn) remotamente no Pi
|
||||
|
||||
## Hello World
|
||||
|
||||
É tradicional, ao começar com uma nova linguagem de programação ou tecnologia, criar um aplicativo 'Hello World' - um pequeno aplicativo que produz algo como o texto `"Hello World"` para mostrar que todas as ferramentas estão configuradas corretamente.
|
||||
|
||||
O aplicativo Hello World para o Pi garantirá que você tenha o Python e o Visual Studio Code instalados corretamente.
|
||||
|
||||
Este aplicativo estará em uma pasta chamada `nightlight` e será reutilizado com código diferente em partes posteriores desta tarefa para construir o aplicativo nightlight.
|
||||
|
||||
### Tarefa - hello world
|
||||
|
||||
Crie o aplicativo Hello World.
|
||||
|
||||
1. Inicie o VS Code, diretamente no Pi ou em seu computador e conectado ao Pi usando a extensão Remote SSH
|
||||
|
||||
1. Inicie o Terminal do VS Code selecionando *Terminal -> Novo Terminal* ou pressionando `` CTRL+` ``. Ele será aberto no diretório inicial dos usuários `pi`.
|
||||
|
||||
1. Execute os seguintes comandos para criar um diretório para o seu código e crie um arquivo Python chamado `app.py` dentro desse diretório:
|
||||
|
||||
```sh
|
||||
mkdir nightlight
|
||||
cd nightlight
|
||||
touch app.py
|
||||
```
|
||||
|
||||
1. Abra esta pasta no VS Code selecionando *File -> Open...* e selecionando a pasta *nightlight* e, em seguida, selecione **OK**
|
||||
|
||||
|
||||
|
||||
1. Abra o arquivo `app.py` no VS Code explorer e adicione o seguinte código:
|
||||
|
||||
```python
|
||||
print('Hello World!')
|
||||
```
|
||||
|
||||
A função `print` imprime tudo o que é passado para ela no console.
|
||||
|
||||
1. No Terminal do VS Code, execute o seguinte para executar seu aplicativo Python:
|
||||
|
||||
```sh
|
||||
python3 app.py
|
||||
```
|
||||
|
||||
> 💁 Você precisa chamar explicitamente `python3` para executar este código apenas no caso de ter o Python 2 instalado além do Python 3 (a versão mais recente). Se você tiver Python2 instalado, chamar `python` usará Python 2 em vez de Python 3
|
||||
|
||||
A seguinte saída aparecerá no terminal:
|
||||
|
||||
```output
|
||||
pi@raspberrypi:~/nightlight $ python3 app.py
|
||||
Hello World!
|
||||
```
|
||||
|
||||
> 💁 Você pode encontrar este código na pasta [code/pi](code/pi).
|
||||
|
||||
😀 Seu programa 'Hello World' foi um sucesso!
|
||||
@ -0,0 +1,210 @@
|
||||
# Computador de placa única virtual
|
||||
|
||||
Em vez de comprar um dispositivo IoT, junto com sensores e atuadores, você pode usar seu computador para simular o hardware IoT. O [projeto CounterFit](https://github.com/CounterFit-IoT/CounterFit) permite que você execute um aplicativo localmente que simula hardware IoT, como sensores e atuadores, e acesse os sensores e atuadores a partir do código Python local que está escrito da mesma forma que o código que você escreveria em um Raspberry Pi usando um hardware físico.
|
||||
|
||||
## Configuração
|
||||
|
||||
Para usar o CounterFit, você precisará instalar alguns softwares gratuitos em seu computador.
|
||||
|
||||
### Tarefa
|
||||
|
||||
Instale o software necessário.
|
||||
|
||||
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ê está livre para usar qualquer IDE ou editor de código Python para essas lições se tiver uma ferramenta preferida, mas as lições darão instruções baseadas no uso do VS Code.
|
||||
|
||||
1. Instale a extensão Pylance do VS Code. Esta é uma extensão para VS Code que fornece suporte à linguagem Python. Consulte a [documentação da extensão Pylance](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance&WT.mc_id=academic-17441-jabenn) para obter instruções sobre como instalar esta extensão no VS Code.
|
||||
|
||||
As instruções para instalar e configurar o aplicativo CounterFit serão fornecidas no momento relevante nas instruções de atribuição, uma vez que é instalado por projeto.
|
||||
|
||||
## Hello world
|
||||
|
||||
É tradicional, ao começar com uma nova linguagem de programação ou tecnologia, criar um aplicativo 'Hello World' - um pequeno aplicativo que produz algo como o texto `"Hello World"` para mostrar que todas as ferramentas estão configuradas corretamente.
|
||||
|
||||
O aplicativo Hello World para o hardware IoT virtual garantirá que você tenha o Python e o Visual Studio Code instalados corretamente. Ele também se conectará ao CounterFit para os sensores e atuadores IoT virtuais. Ele não usará nenhum hardware, apenas se conectará para provar que tudo está funcionando.
|
||||
|
||||
Este aplicativo estará em uma pasta chamada `nightlight` e será reutilizado com código diferente em partes posteriores desta atribuição para construir o aplicativo nightlight.
|
||||
|
||||
### Configure 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, em seguida, usar esse pacote em seu código. Você usará o pip para instalar um pacote para falar com o CounterFit.
|
||||
|
||||
Por padrão, quando você instala um pacote, ele está disponível em qualquer lugar do seu computador, e isso pode causar 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 ao instalar o pip pacotes são instalados apenas nessa pasta.
|
||||
|
||||
#### Tarefa - configurar um ambiente virtual Python
|
||||
|
||||
Configure um ambiente virtual Python e instale os pacotes pip para CounterFit.
|
||||
|
||||
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
|
||||
cd nightlight
|
||||
```
|
||||
|
||||
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 apenas no caso de ter o Python 2 instalado além do Python 3 (a versão mais recente). Se você tiver Python2 instalado, chamar `python` usará Python 2 em vez de Python 3
|
||||
|
||||
1. Ative o ambiente virtual:
|
||||
|
||||
* No Windows, execute:
|
||||
|
||||
```cmd
|
||||
.venv \ Scripts \ activate.bat
|
||||
```
|
||||
|
||||
* No macOS ou Linux, execute:
|
||||
|
||||
```cmd
|
||||
source ./.venv/bin/activate
|
||||
```
|
||||
|
||||
1. Uma vez que o ambiente virtual foi ativado, o comando padrão `python` irá 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 deve conter o seguinte:
|
||||
|
||||
```output
|
||||
(.venv) ➜ nightlight 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ê está bem. Caso contrário, exclua esta pasta, instale uma versão mais recente do Python e tente novamente.
|
||||
|
||||
1. Execute os seguintes comandos para instalar os pacotes pip para CounterFit. Esses pacotes incluem o aplicativo CounterFit principal, bem como shims para hardware Grove. Esses shims permitem que você escreva código como se estivesse programando usando sensores e atuadores físicos do ecossistema Grove, mas conectado a dispositivos IoT virtuais.
|
||||
|
||||
```sh
|
||||
pip install CounterFit
|
||||
pip install counterfit-connection
|
||||
pip install counterfit-shims-grove
|
||||
```
|
||||
|
||||
Esses pacotes pip só serão instalados no ambiente virtual e não estarão disponíveis fora dele.
|
||||
|
||||
### Escreva o código
|
||||
|
||||
Assim que o ambiente virtual Python estiver pronto, você pode escrever o código para o aplicativo 'Hello World'
|
||||
|
||||
#### Tarefa - escreva o código
|
||||
|
||||
Crie um aplicativo Python para imprimir `" Hello World "` no console.
|
||||
|
||||
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 .
|
||||
```
|
||||
|
||||
> 💁 Se o seu terminal retornar `command not found` no macOS, significa que o VS Code não foi adicionado ao seu PATH. Você pode adicionar o VS Code ao seu PATH seguindo as instruções na seção [Iniciando a partir da linha de comando da documentação do código do VS](https://code.visualstudio.com/docs/setup/mac?WT.mc_id=academic-17441-jabenn#_launching-from-the-command-line) e execute o comando depois. O VS Code é instalado em seu PATH por padrão no Windows e Linux.
|
||||
|
||||
1. Quando o VS Code for iniciado, ele ativará o ambiente virtual Python. O ambiente virtual selecionado aparecerá na barra de status inferior:
|
||||
|
||||
|
||||
|
||||
1. Se o Terminal do VS Code 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 a fazer é matar o terminal usando o botão **Kill the active terminal instance**:
|
||||
|
||||
|
||||
|
||||
Você pode dizer se o terminal tem o ambiente virtual ativado, pois o nome do ambiente virtual será um prefixo no prompt do terminal. Por exemplo, pode ser:
|
||||
|
||||
```sh
|
||||
(.venv) ➜ nightlight
|
||||
```
|
||||
|
||||
Se você não tiver `.venv` como prefixo no prompt, o ambiente virtual não está ativo no terminal.
|
||||
|
||||
1. Inicie um novo Terminal do VS Code selecionando *Terminal -> Novo Terminal* ou pressionando `` CTRL+` ``. O novo terminal irá carregar o ambiente virtual, e a chamada para ativá-lo aparecerá no terminal. O prompt também terá o nome do ambiente virtual (`.venv`):
|
||||
|
||||
```output
|
||||
➜ nightlight source .venv/bin/activate
|
||||
(.venv) ➜ nightlight
|
||||
```
|
||||
|
||||
1. Abra o arquivo `app.py` no VS Code explorer e adicione o seguinte código:
|
||||
|
||||
```python
|
||||
print('Hello World!')
|
||||
```
|
||||
|
||||
A função `print` imprime no console tudo o que é passado para ela.
|
||||
|
||||
1. No terminal do VS Code, execute o seguinte para executar seu aplicativo Python:
|
||||
|
||||
```sh
|
||||
python app.py
|
||||
```
|
||||
|
||||
O seguinte estará na saída:
|
||||
|
||||
```output
|
||||
(.venv) ➜ nightlight python app.py
|
||||
Hello World!
|
||||
```
|
||||
|
||||
😀 Seu programa 'Hello World' foi um sucesso!
|
||||
|
||||
### Conecte o 'hardware'
|
||||
|
||||
Como uma segunda etapa 'Hello World', você executará o aplicativo CounterFit e conectará seu código a ele. Isso é o equivalente virtual de conectar algum hardware IoT a um kit de desenvolvimento.
|
||||
|
||||
#### Tarefa - conecte o 'hardware'
|
||||
|
||||
1. A partir do terminal do VS Code, inicie o aplicativo CounterFit com o seguinte comando:
|
||||
|
||||
```sh
|
||||
CounterFit
|
||||
```
|
||||
|
||||
O aplicativo começará a funcionar e abrir no seu navegador da web:
|
||||
|
||||
|
||||
|
||||
Ele será marcado como *Desconectado*, com o LED no canto superior direito apagado.
|
||||
|
||||
1. Adicione o seguinte código ao topo de `app.py`:
|
||||
|
||||
```python
|
||||
from counterfit_connection import CounterFitConnection
|
||||
CounterFitConnection.init('127.0.0.1', 5000)
|
||||
```
|
||||
|
||||
Este código importa a classe `CounterFitConnection` do módulo` counterfit_connection`, que vem do pacote pip `counterfit-connection` que você instalou anteriormente. Em seguida, ele inicializa uma conexão com o aplicativo CounterFit em execução em `127.0.0.1`, que é um endereço IP que você sempre pode usar para acessar seu computador local (muitas vezes referido como *localhost*), na porta 5000.
|
||||
|
||||
> 💁 Se você tiver outros aplicativos em execução na porta 5000, pode alterar isso atualizando a porta no código e executando o CounterFit usando `CounterFit --port <port_number>`, substituindo `<port_number>` pela porta que deseja usar.
|
||||
|
||||
1. Você precisará iniciar um novo terminal do VS Code selecionando o botão **Create a new integrated terminal**. Isso ocorre porque o aplicativo CounterFit está sendo executado no terminal atual.
|
||||
|
||||
|
||||
|
||||
1. Neste novo terminal, execute o arquivo `app.py` como antes. O status do CounterFit mudará para **Conectado** e o LED acenderá.
|
||||
|
||||
|
||||
|
||||
> 💁 Você pode encontrar este código na pasta [code/virtual-device](../code/virtual-device).
|
||||
|
||||
😀 Sua conexão com o hardware foi um sucesso!
|
||||
@ -0,0 +1,198 @@
|
||||
# Wio Terminal
|
||||
|
||||
O [Wio Terminal da Seeed Studios] (https://www.seeedstudio.com/Wio-Terminal-p-4509.html) é um microcontrolador compatível com Arduino, com WiFi e alguns sensores e atuadores integrados, bem como portas para adicionar mais sensores e atuadores, usando um ecossistema de hardware chamado [Grove] (https://www.seeedstudio.com/category/Grove-c-1003.html).
|
||||
|
||||
|
||||
|
||||
## Configuração
|
||||
|
||||
Para usar o Wio Terminal, você precisará instalar algum software gratuito no computador. Você também precisará atualizar o firmware do Wio Terminal antes de conectá-lo ao WiFi.
|
||||
|
||||
### Tarefa - configuração
|
||||
|
||||
Instale o software necessário e atualize o firmware.
|
||||
|
||||
1. Instale o Visual Studio Code (VS Code). Este é o editor que você usará para escrever o código do seu dispositivo em C/C++. 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.
|
||||
|
||||
> 💁 Outro IDE popular para o desenvolvimento do Arduino é o [Arduino IDE](https://www.arduino.cc/en/software). Se você já está familiarizado com esta ferramenta, você pode usá-la em vez do VS Code e PlatformIO, mas as lições darão instruções baseadas no uso do VS Code.
|
||||
|
||||
1. Instale a extensão PlatformIO do VS Code. Esta é uma extensão do VS Code que oferece suporte à programação de microcontroladores em C/C++. Consulte a [documentação da extensão PlatformIO](https://marketplace.visualstudio.com/items?itemName=platformio.platformio-ide&WT.mc_id=academic-17441-jabenn) para obter instruções sobre como instalar esta extensão no VS Code. Esta extensão depende da extensão Microsoft C/C++ para funcionar com código C e C ++, e a extensão C/C++ é instalada automaticamente quando você instala a extensão PlatformIO.
|
||||
|
||||
1. Conecte o Wio Terminal ao computador. O Wio Terminal possui uma porta USB-C na parte inferior e ela precisa ser conectada a uma porta USB no seu computador. O Wio Terminal vem com um cabo USB-C para USB-A, mas se o seu computador tiver apenas portas USB-C, você precisará de um cabo USB-C ou de um adaptador USB-A para USB-C.
|
||||
|
||||
1. Siga as instruções na [documentação de visão geral de WiFi da Wiki do Wio Terminal](https://wiki.seeedstudio.com/Wio-Terminal-Network-Overview/) para configurar seu Wio Terminal e atualizar o firmware.
|
||||
|
||||
## Hello World
|
||||
|
||||
É tradicional, ao começar com uma nova linguagem de programação ou tecnologia, criar um aplicativo 'Hello World' - um pequeno aplicativo que produz algo como o texto `"Hello World"` para mostrar que todas as ferramentas estão configuradas corretamente.
|
||||
|
||||
O aplicativo Hello World para o Wio Terminal garantirá que você tenha o Visual Studio Code instalado corretamente com PlatformIO e configurado para desenvolvimento de microcontrolador.
|
||||
|
||||
### Crie um projeto PlatformIO
|
||||
|
||||
A primeira etapa é criar um novo projeto usando PlatformIO configurado para o Wio Terminal.
|
||||
|
||||
#### Tarefa - criar um projeto PlatformIO
|
||||
|
||||
Crie o projeto PlatformIO.
|
||||
|
||||
1. Conecte o Wio Terminal ao seu computador
|
||||
|
||||
1. Inicie o VS Code
|
||||
|
||||
1. O ícone PlatformIO estará na barra de menu lateral:
|
||||
|
||||
|
||||
|
||||
Selecione este item de menu e, em seguida, selecione *PIO Home -> Open*
|
||||
|
||||
|
||||
|
||||
1. Na tela de boas-vindas, selecione o botão **+ New Project**
|
||||
|
||||
|
||||
|
||||
1. Configure o projeto no *Project Wizard*:
|
||||
|
||||
1. Nomeie seu projeto como `nightlight`
|
||||
|
||||
1. No dropdown de *Board*, digite `WIO` para filtrar as placas e selecione *Seeeduino Wio Terminal*
|
||||
|
||||
1. Deixe o *Framework* como *Arduino*
|
||||
|
||||
1. Deixe a caixa de seleção *Use default location* marcada, ou desmarque-a e selecione um local para o seu projeto
|
||||
|
||||
1. Selecione o botão **Finish**
|
||||
|
||||
|
||||
|
||||
PlatformIO baixará os componentes necessários para compilar o código para o Wio Terminal e criar seu projeto. Isso pode levar alguns minutos.
|
||||
|
||||
### Investigue o projeto PlatformIO
|
||||
|
||||
O explorador do VS Code mostrará vários arquivos e pastas criados pelo assistente PlatformIO.
|
||||
|
||||
#### Pastas
|
||||
|
||||
* `.pio` - esta pasta contém dados temporários necessários para PlatformIO, como bibliotecas ou código compilado. Ela é recriada automaticamente se excluída e você não precisa adicioná-la ao controle do código-fonte se estiver compartilhando seu projeto em sites como o GitHub.
|
||||
* `.vscode` - esta pasta contém a configuração usada por PlatformIO e VS Code. Ela é recriada automaticamente se excluída e você não precisa adicioná-la ao controle do código-fonte se estiver compartilhando seu projeto em sites como o GitHub.
|
||||
* `include` - esta pasta é para arquivos de cabeçalho externos necessários ao adicionar bibliotecas adicionais ao seu código. Você não usará esta pasta em nenhuma dessas lições.
|
||||
* `lib` - esta pasta é para bibliotecas externas que você deseja chamar de seu código. Você não usará esta pasta em nenhuma dessas lições.
|
||||
* `src` - esta pasta contém o código-fonte principal do seu aplicativo. Inicialmente, ele conterá um único arquivo - `main.cpp`.
|
||||
* `test` - esta pasta é onde você colocaria quaisquer testes de unidade para o seu código
|
||||
|
||||
#### Arquivos
|
||||
|
||||
* `main.cpp` - este arquivo na pasta `src` contém o ponto de entrada para sua aplicação. Abra este arquivo e ele conterá o seguinte código:
|
||||
|
||||
```cpp
|
||||
#include <Arduino.h>
|
||||
|
||||
void setup() {
|
||||
// coloque seu código de configuração aqui, para ser executado uma vez:
|
||||
}
|
||||
|
||||
void loop() {
|
||||
// coloque seu código principal aqui, para executar repetidamente:
|
||||
}
|
||||
```
|
||||
|
||||
Quando o dispositivo é inicializado, a estrutura do Arduino executará a função `setup` uma vez e, em seguida, executará a função `loop` repetidamente até que o dispositivo seja desligado.
|
||||
|
||||
* `.gitignore` - este arquivo lista os arquivos e diretórios a serem ignorados ao adicionar seu código ao controle de código-fonte do git, como enviar para um repositório no GitHub.
|
||||
|
||||
* `platformio.ini` - este arquivo contém a configuração para seu dispositivo e aplicativo. Abra este arquivo e ele conterá o seguinte código:
|
||||
|
||||
```ini
|
||||
[env:seeed_wio_terminal]
|
||||
platform = atmelsam
|
||||
board = seeed_wio_terminal
|
||||
framework = arduino
|
||||
```
|
||||
|
||||
A seção `[env:seeed_wio_terminal]` tem configuração para o Wio Terminal. Você pode ter várias seções `env` para que seu código possa ser compilado para várias placas.
|
||||
|
||||
Os outros valores correspondem à configuração do assistente de projeto:
|
||||
|
||||
* `platform = atmelsam` define o hardware que o Wio Terminal usa (um microcontrolador baseado em ATSAMD51)
|
||||
* `board = seeed_wio_terminal` define o tipo de placa do microcontrolador (o Wio Terminal)
|
||||
* `framework = arduino` define que este projeto está usando o framework Arduino.
|
||||
|
||||
### Escreva o aplicativo Hello World
|
||||
|
||||
Agora você está pronto para escrever o aplicativo Hello World.
|
||||
|
||||
#### Tarefa - escrever o aplicativo Hello World
|
||||
|
||||
Escreva o aplicativo Hello World.
|
||||
|
||||
1. Abra o arquivo `main.cpp` no VS Code
|
||||
|
||||
1. Altere o código para corresponder ao seguinte:
|
||||
|
||||
```cpp
|
||||
#include <Arduino.h>
|
||||
|
||||
void setup()
|
||||
{
|
||||
Serial.begin(9600);
|
||||
|
||||
while (!Serial)
|
||||
; // Aguarde até que o Serial esteja pronto
|
||||
|
||||
delay(1000);
|
||||
}
|
||||
|
||||
void loop()
|
||||
{
|
||||
Serial.println("Hello World");
|
||||
delay(5000);
|
||||
}
|
||||
```
|
||||
|
||||
A função `setup` inicializa uma conexão com a porta serial - neste caso, a porta USB que é usada para conectar o Wio Terminal ao seu computador. O parâmetro `9600` é a [taxa de transmissão](https://wikipedia.org/wiki/Symbol_rate) (também conhecida como taxa de símbolo), ou velocidade com que os dados serão enviados pela porta serial em bits por segundo. Essa configuração significa que 9.600 bits (0s e 1s) de dados são enviados a cada segundo. Em seguida, ele espera que a porta serial esteja pronta.
|
||||
|
||||
A função `loop` envia a linha `Hello World!` para a porta serial, então os caracteres de `Hello World!` junto com um caractere de nova linha. Em seguida, ele dorme por 5.000 milissegundos ou 5 segundos. Depois que o `loop` termina, ele é executado novamente, e novamente, e assim por diante, o tempo todo em que o microcontrolador permanece ligado.
|
||||
|
||||
1. Construa e carregue o código para o Wio Terminal
|
||||
|
||||
1. Abra a paleta de comando do VS Code
|
||||
|
||||
1. Digite `PlatformIO Upload` para pesquisar a opção de upload e selecione *PlatformIO: Upload*
|
||||
|
||||
|
||||
|
||||
PlatformIO construirá automaticamente o código, se necessário, antes de fazer o upload.
|
||||
|
||||
1. O código será compilado e enviado para o Wio Terminal
|
||||
|
||||
> 💁 Se você estiver usando o macOS, será exibida uma notificação sobre um *DISCO NÃO EJETADO CORRETAMENTE*. Isso ocorre porque o Wio Terminal é montado como uma unidade como parte do processo de flashing e é desconectado quando o código compilado é gravado no dispositivo. Você pode ignorar esta notificação.
|
||||
|
||||
⚠️ Se você receber erros sobre a porta de upload não estar disponível, primeiro certifique-se de ter o Wio Terminal conectado ao seu computador e ligado usando o botão no lado esquerdo da tela. A luz verde na parte inferior deve estar acesa. Se você ainda receber o erro, puxe o botão liga/desliga para baixo duas vezes em rápida sucessão para forçar o Wio Terminal no modo bootloader e tente fazer o upload novamente.
|
||||
|
||||
PlatformIO tem um monitor serial que pode monitorar os dados enviados pelo cabo USB do Wio Terminal. Isso permite que você monitore os dados enviados pelo comando `Serial.println("Hello World");`.
|
||||
|
||||
1. Abra a paleta de comando do VS Code
|
||||
|
||||
1. Digite `PlatformIO Serial` para pesquisar a opção Serial Monitor e selecione *PlatformIO: Serial Monitor*
|
||||
|
||||
|
||||
|
||||
Um novo terminal será aberto e os dados enviados pela porta serial serão transmitidos para este terminal:
|
||||
|
||||
```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.usbmodem101 9600,8,N,1 ---
|
||||
--- Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H ---
|
||||
Hello World
|
||||
Hello World
|
||||
```
|
||||
|
||||
`Hello World` será impresso no monitor serial a cada 5 segundos.
|
||||
|
||||
> 💁 Você pode encontrar este código na pasta [code/wio-terminal](../code/wio-terminal).
|
||||
|
||||
😀 Seu programa 'Hello World' foi um sucesso!
|
||||
Loading…
Reference in new issue