Pequeno Projeto De Uma Casa Inteligente: 5 Passos

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

O projeto que faremos é de uma casa inteligente. Possui basicamente dois grupos de funcionalidades: · De monitoramento de iluminação e temperatura dos cômodos.

· Monitoramento da lista de alimentos e nível de água filtrada na geladeira.

Não escreveremos os firmwares dos dispositivos IoT da gel nem dos cômodos; porém assume que os dispositivos fazem o seguinte:

- A geladeira possui um dispositivo com touchscreen em que é possível entrar com dados de alimentos: o nome de um alimento e sua quantidade;

- A geléia possui um sensor de nível em um pequeno tanque de água embutido na geladeira;

- Os cômodos têm termômetros e sensores de iluminância;

- Os cômodos têm ar condicionado que se comunicam pela rede wifi;

- As lâmpadas dos cômodos podem ter o brilho para o dispositivo que se comunica pela rede wifi;

Requisitos:

- Conhecimento básico em python, javascript, uso do sistema operacional, comandos básicos no shell

- Ter instalado: nodejs, python

- Ter instalado (opcional): docker, emulador de dispositivo mobile, gerenciador de sdk do Android (disponível no Android Studio)

O desenvolvimento desse projeto foi feito no Linux. Podem ser adaptadas para que seja feito no Windows.

Etapa 1: Configurando O Ambiente

Vamos configurar o ambiente de desenvolvimento em 2 partes: servidor e mobile. O servidor será escrito em python e o mobile em javascript ou typecript, sendo usado React Native para o projeto.

reactnative.dev/

Vamos bolar criar uma estrutura de massas. Em um selecionado escolhido (que a partir de agora será escrito sempre como $ PROJECT_DIR como placeholder - crie com no local que achar mais adequado e com o nome de sua preferência), vamos criar uma pasta "servidor":

$ mkdir $ PROJECT_DIR && cd $ PROJECT_DIR

$ mkdir servidor

CONFIGURANDO O AMBIENTE DE DESENVOLVIMENTO PARA O SERVIDOR

Podemos usar um ambiente conteinerizado com Docker ou ambiente virtual python (venv). Caso deseje utilizar ambiente conteinerizado, criaremos uma imagem segundo o dockerfile:

$ cd $ PROJECT_DIR

$ touch dockerfile

Veja imagem do dockerfile.

Caso prefira usar ambiente virtual do python, siga as instruções em

Vamos então criar o arquivo que persistirá a lista de dependências do servidor e colocar conforme as dependências necessárias:

$ touch requirements.txt

Veja imagem do requirements.txt.

Caso tenha optado por utilizar um ambiente conteinerizado, construa a imagem e entre no container:

construção de $ docker. -t smarthouse $ docker run -it -p 3000: 3000 -v $ (pwd): / app smarthouse bash

Para mais informações sobre o dockerfile e um clique do docker:

CONFIGURANDO O AMBIENTE DE DESENVOLVIMENTO MOBILE

Um passo a passo de como configurar o ambiente de desenvolvimento mobile com React Native pode ser visto no link:

Após ter o ambiente definido, na pasta do projeto deve ser possível executar o comando para criar um aplicativo móvel:

Cliente $ npx create-react-native-app

Etapa 2: WebSocket

É interessante que o leitor conheço pelo menos um pouco a respeito de websocket antes de prosseguir. Caso o leitor nunca tenha lido, trabalhado ou ouvido falar nada a respeito, separe alguns minutos para entender como funciona o websocket através dos documentos:

developer.mozilla.org/pt-BR/docs/WebSocket…

Usaremos uma biblioteca no cliente e no servidor que abstrai o protocolo de maneira que não precisemos pensar em detalhes de chamada e de armazenamento de identificadores e rotas. Separe também um tempo para estudar as bibliotecas utilizadas no cliente e no servidor:

Cliente:

Servidor:

Etapa 3: Escrevendo O Servidor

Vamos criar uma estrutura inicial do projeto e escrever uma interface que será usada como comunicação com o servidor:

$ mkdir src

$ touch app.py src / {controlador, socketconnection}.py

Primeiramente vamos escrever um módulo de inicalização do servidor:

Veja imagem do app.py

Depois vamos escrever o módulo que serviço como limitado via websocket e como redirecionam para um controlador.

Veja imagem do socketconnection.py

CONTROLLER E USECASES

O controlador receberá um pacote do módulo responsável por definir e gerenciar como consertado; será responsável do driver sabre qual função de caso de uso chamar para cada ambiente de envio, bem como a partir da resposta do caso de uso enviar um pacote de resposta para uma sala de dispositivos conectados para atualização das informações.

Veja imagem do controller.py.

Finalmente, os casos de uso que devem gerenciar como deve ser tratado os dados do evento de saída e criar os novos dados a partir dos dados recebidos para que o controlador atualize o estado do sistema. No caso desse sistema há somente atualização de valores (sejam numéricos, texto ou booleanos - no caso de ligar / desligar dispositivos de ambientação). Então não é de surpreender que os casos de uso tão somente chame funções do módulo responsável pela persistência de dados como se fosse essa a "regra de negócio".

Veja imagem do usecases.py

Nota: precisamos persistir os dados de alguma forma. Fica a escolha do leitor como prefere armazenar os dados e portanto, implementar as funções do src / repository.py. No projeto desenvolvido como exemplo foi persistido em um arquivo json no banco de dados selecionado. No repositório do projeto é possível verificar uma pasta servidor / banco de dados com um arquivo com os dados persistidos bem como um arquivo de modelo em servidor / banco de dados-model.json de como deve ser o json para a nossa aplicação funcionar.

Etapa 4: Testando O Servidor

Podemos criar um script para conectar ao servidor e enviar eventos conforme uma estrutura esperada pelos drivers para fins de testes manuais. Vamos criar esse script e rodá-lo com o servidor *.

Veja imagem do serverclient.py

Com o arquivo criado, se o container está rodando, e dentro dele execute:

$ python app.py

Fora do container, no diretório $ PROJECT_DIR / server execute:

$ python3 serverclient.py

Sem prompt ">" digite os eventos encontrados no controlador seguido de ";" e então valores de identificação e / ou novos valores. Por exemplo:

UPDATE_FRIDGE_WATER_LEVEL; 80

UPDATE_ROOM_TEMPERATURE; 1, 22.0

UPDATE_ROOM_TEMPERATURE_SETPOINT; 1, 17.5

UPDATE_ROOM_LUMINOSITY; 100

UPDATE_ROOM_LUMINOSITY_SETPOINT; 0

TOGGLE_ROOM_TEMPERATURE; 1

TOGGLE_ROOM_LIGHT; 1

E para cada evento enviado se foi persistido no banco de dados selecionado.

Nota: a porta que está sendo servido a aplicação, a porta exposta no docker run e a porta do script de teste devem ser a mesma.

Etapa 5: A Aplicação Mobile

Não será alterado com muitos detalhes de cada parte do desenvolvimento do cliente mobile. Não será explicitado aqui cada importação no módulo principal criado pelo React Native nem possíveis detalhes de configuração. Para começar, navegue até $ PROJECT_DIR / client e dependente a dependência que precisaremos para o projeto:

$ npm i socket.io

Em seguida vamos escrever os componentes gráficos e as funções que irão se comunicar com o servidor.

ESCREVENDO A TELA

Em App.js, vamos escrever os componentes de GUI.

⚠ Note que a função chamada pelo useEffect ainda não foi escrita! Também não foram escritos os redutores setDataReducer, setFoodReducer, setTemperatureReducer, setLightReducer e nem escritos os objetos com estados iniciais INITIAL_STATE, INITIAL_FOOD_MODAL, INITIAL_TEMPERATURE_MODAL, INITIAL_LIGHT_MODAL ⚠

Também ainda não foram escritas como funções utilizadas pelos elementos de inteface gráfica para fazer chamadas para escrita no servidor: saveNewFoodValue, saveNewTemperature, saveNewLuminosity, toggleTemperatureForRoom, toggleLightForRoom

Portanto, se desejar testar os elementos com dados falsos, escrever cada objeto e função dito acima.

Veja imagem do App.js com código da parte GUI

Por fim vamos escrever as funções necessárias para fazer a comunicação com o servidor e para utlização do mesmo pelos componentes de GUI.

Veja imagem do App.js com código da parte lógica / operacional