10 KiB

Raw Blame History

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

Instale o Python. Consulte a página de downloads do Python para obter instruções sobre como instalar a versão mais recente do Python.
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 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.
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 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 - 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, 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.

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:
```
mkdir nightlight
cd nightlight
```
Agora execute o seguinte para criar um ambiente virtual na pasta .venv
```
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
Ative o ambiente virtual:
- No Windows, execute:
```
.venv \ Scripts \ activate.bat
```
- No macOS ou Linux, execute:
```
source ./.venv/bin/activate
```
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:
```
python --version
```
A saída deve conter o seguinte:
```
(.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.
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.
```
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.

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:
```
type nul > app.py
```
- No macOS ou Linux, execute:
```
touch app.py
```
Abra a pasta atual no VS Code:
```
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 e execute o comando depois. O VS Code é instalado em seu PATH por padrão no Windows e Linux.
Quando o VS Code for iniciado, ele ativará o ambiente virtual Python. O ambiente virtual selecionado aparecerá na barra de status inferior:
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:
```
(.venv) ➜  nightlight
```
Se você não tiver .venv como prefixo no prompt, o ambiente virtual não está ativo no terminal.
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):
```
➜  nightlight source .venv/bin/activate
(.venv) ➜  nightlight 
```
Abra o arquivo app.py no VS Code explorer e adicione o seguinte código:
```
print('Hello World!')
```
A função print imprime no console tudo o que é passado para ela.
No terminal do VS Code, execute o seguinte para executar seu aplicativo Python:
```
python app.py
```
O seguinte estará na saída:
```
(.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'

A partir do terminal do VS Code, inicie o aplicativo CounterFit com o seguinte comando:
```
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.
Adicione o seguinte código ao topo de app.py:
```
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.
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.
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.

😀 Sua conexão com o hardware foi um sucesso!

10 KiB Raw Blame History