Pequeno Projeto De Uma Casa Inteligente: 5 Pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:40

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

· De monitoramente de lista de alimentos e nível de agua filtrada na geladeira.

Não escreveremos os firmwares dos dispositivos IoT da geladeira nem dos cômodos; porém assumiremos 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;

- Un sensor de geladeira possui um de nível em um pequeño 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 ajustado por dispositivo que se comunica pela rede wifi;

Requisitos:

- Conhecimento básico en python, javascript, uso del sistema operacional, comandos básicos sin shell

- Ter instalado: nodejs, python

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

O desenvolvimento desse projeto foi feito no Linux. Podem ser necessárias adaptações para que seja feito no Windows.

Paso 1: Configurando O Ambiente

Vamos a configurar o ambiente de desenvolvimento en 2 partes: servidor e móvil.

reactnative.dev/

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

$ mkdir $ PROJECT_DIR && cd $ PROJECT_DIR

$ mkdir servidor

CONFIGURANDO O AMBIENTE DE DESENVOLVIMENTO PARA O SERVIDOR

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

$ cd $ PROJECT_DIR

$ touch dockerfile

Veja imagem dockerfile.

Caso prefira utilizar ambiente virtual do python, siga las instrucciones en

Vamos a crear una lista de dependencias del servidor y colocarla como dependencias necesarias:

$ touch requirements.txt

Veja imagem do requirements.txt.

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

$ compilación de docker. -t smarthouse $ docker run -it -p 3000: 3000 -v $ (pwd): / app smarthouse bash

Para más información sobre o dockerfile e a cli do docker:

CONFIGURANDO O AMBIENTE DE DESENVOLVIMENTO MÓVIL

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 establecido, na pasta do projeto deve ser posible ejecutar o comando para criar una aplicación móvil:

Cliente $ npx create-react-native-app

Paso 2: WebSocket

É interessante que o leitor conheça 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 da documentação:

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

Usaremos uma biblioteca no cliente e no servidor que abstrai o protocolo de maneira que no precisamos pensar em detalhes de chamada e de armazenamento de identificadores e rotaciones. Separe también um tempo para estudar as bibliotecas utilizadas no cliente e no servidor:

Cliente:

Servidor:

Paso 3: Escrevendo O Servidor

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

$ mkdir src

$ touch app.py src / {controlador, conexión de enchufe}.py

Primeiramente vamos a escrever um módulo de inicialización del servidor:

Veja imagem do app.py

Depois vamos a resolver el módulo que estabelece como conexiones a través de websocket e como redirecionam para um controlador.

Veja imagem do socketconnection.py

USOS DEL CONTROLADOR E

O controlador receberá um pacote do módulo responsável por estabelecer e gerenciar as conexões; será responsable del controlador saber cual función de caso de uso chamar para cada envento recebido, bem como a partir de la resposta do caso de uso enviar um pacote de resposta para una sala de dispositivos conectados para atualização das informações.

Veja imagem do controller.py.

Finalmente temos os casos de uso que devem gerenciar como deve ser tratado os dados do evento recebido e criar os novos dados a partir de 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 preferencia armazenar os dados e portanto, implement as funções do src / repository.py. No projeto desenvolvido como exemplo foi persistido em um arquivo json no diretório database. No hay un repositorio del proyecto que sea posible verificar un servidor de pasta / base de datos com um arquivo con los datos persistidos como un archivo de modelo en el servidor / modelo de base de datos.json de como deve ser o json para una aplicación que funcione.

Paso 4: Testando O Servidor

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

Veja imagem do serverclient.py

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

$ python app.py

Para hacer contenedor, no diretório $ PROJECT_DIR / server ejecutar:

$ python3 serverclient.py

No prompt ">" digite os eventos encontrados no controlador seguido de ";" e então valores de identificación e / ou novos valores. Por ejemplo:

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 verifique se foi persistido no banco de dados escolhido.

Nota: verifique que 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.

Paso 5: una aplicación móvil

Não será demostrado com muitos detalhes cada parte del 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 adicione a dependência que precisaremos para o projeto:

$ npm i socket.io

Em seguida vamos a ver los componentes gráficos e como funciones que irán se comuniquen con el servidor.

ESCREVENDO A TELA

Em App.js, vamos a explorar los componentes de la GUI.

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

También ainda no foram escritas as 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, escreva cada object and função dito acima.

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

Por fim vamos a explorar como funciones necesarias para fazer a comunicação com o servidor e para utlização do mesmo pelos componentes de GUI.

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