O ESP32 Projeto com Sensor de Fluxo é um sistema de verificação desenvolvido com o intuito de analisar o fluxo de água em um determinado local em específico e possibilitar a sua verificação através de uma conexão WiFi entre o seu celular e o ESP32, por exemplo.
Sistema de monitoramento de dados ESP32 com Sensor de Fluxo
A fácil visualização dos dados proporciona além de tudo um melhor controle do consumo de água em residências e indústrias, evitando gastos excessivos e nos policiando cotidianamente quanto a nossa utilização deste bem tão precioso que é a água.
Além de podermos visualizar os dados através da tela de smartphones, também é possível abrir junto ao computador um arquivo .txt criado junto ao micro cartão SD incluso no projeto, o qual salva os dados e evita que estes precisam ser salvos na EEPROM.
ESP32 NodeMCU
O ESP32 é um Microcontrolador cada vez mais presente na maioria dos projetos e que se diferencia dos tradicionais Arduinos principalmente na sua tensão de nível lógico, já que seu nível lógico é de 3,3V e não 5V como no Arduino.
ESP32 NodeMCU e Arduino
Como a maioria dos sensores são produzidos para funcionar com tensões de 5V, muitas vezes é necessária a inclusão de um divisor de tensão ou de um Conversor de Nível Lógico para o perfeito funcionamento do projeto.
Podendo conectar-se com outros dispositivos tanto através de uma rede sem fio WiFi quanto através do Bluetooth, o ESP32 é um produto que expande bastante a sua capacidade de aplicação nos mais diversificados projetos.
O ESP32 é o chip base que controla o funcionamento do módulo NodeMCU, uma placa responsável pela expansão dos pinos de saída através das barras de pino, uma conexão direta junto ao computador via cabo através do conector Micro USB e possibilidade de alimentações superiores aos 3,3V padrão através de reguladores de tensão.
Existe diferença entre o ESP32 e o ESP32 Nodemcu?
Sim, esta diferença é simples de explicar, o ESP32 é o chip controlador que possibilita as comunicações sem fio e comutação de dados enquanto que o ESP32 Nodemcu é o módulo que se baseia neste chip controlador e agrega algumas funções a mais citadas anteriormente.
ESP32 x ESP32 NodeMCU
ESP32 Projeto – Sensor de Fluxo de Água
O sensor de Fluxo de Água com Arduino é um produto bastante utilizado nas mais diversas aplicações de sistemas de monitoramento para controle de gastos, por exemplo, e pode ser empregado tanto em ambientes industriais quanto residenciais.
Maiores informações sobre o funcionamento do sensor de fluxo de água você encontra no artigo que segue abaixo:
Sensor de Fluxo de Água Arduino como Sensor de Vazão para Projetos
Normalmente, o Sensor de Fluxo de Água possui especificações de uso próximas aos 5V, porém para a realização deste projeto verificamos a fundo o seu sistema de funcionamento e através da necessidade de utilizar um nível lógico de 3,3V descobrimos que ele é compatível também com tensões menores de 4,5V.
Ao estudar a fundo o sistema de funcionamento do Sensor de Efeito Hall, verificou-se a sua alimentação poderia trabalhar com tensões de aproximadamente 3V, o que possibilitaria trabalharmos com o sensor de Fluxo de água através dos 3,3V necessários para leitura do ESP32.
Após submeter ambos os produtos a um teste de funcionamento verificou-se a possibilidade de realizar tal procedimento.
ESP32 Projeto – Módulo Relógio Tempo Real RTC DS1307
Utilizado como ferramenta para verificação de dados referente à data e o horário, o Módulo RTC proporciona ao seu projeto uma estabilidade de informações quanto a estas duas variáveis. Maiores informações quanto a utilização do Módulo RTC DS1307 você encontra no Artigo abaixo:
Módulo RTC DS1307 com Display 16×2 I2C – Relógio Arduino com Despertador
Como já expresso anteriormente, a necessidade de utilizar 5V de alguns produtos é inegável e nestes casos ao utilizá-los no ESP32 é necessária a inclusão de um conversor. Ao utilizarmos o Módulo RTC DS1307, porém nos deparamos com uma característica diferenciada própria da comunicação I2C que é a sua capacidade de trabalho com tensões também de 3,3V.
Desta maneira, podemos utilizar o Módulo RTC diretamente no ESP32 sem problema, porém mesmo que o sinal lógico fique nos 3,3V do ESP, a alimentação do módulo ainda deve ser feita através dos 5V do Microcontrolador, obtidos através da porta Vin.
ESP32 Projeto – Mini SD Card Arduino para Cartão Micro SD
O módulo Mini SD Card é o responsável pela leitura do cartão SD, produto o qual armazenará as informações do projeto, as datas e fluxo total por dia, tudo isto através de um Arquivo txt.
Diferente dos demais componentes elencados anteriormente, o Módulo Leitor de Cartão Micro SD possui uma alimentação e um nível lógico estabilizado nos 3,3V, sendo desenvolvido para uso específico em microcontroladores com esta tensão de comunicação e funcionamento.
Pinos do Mini SD Card
A conexão e a pinagem do Módulo para Cartão Micro SD é bastante simples e conta com apenas 6 conexões, das quais duas são para a alimentação de 3,3V. Veja um pouco mais sobre os pinos que constituem este produto:
Pinos de conexão do Mini SD Card
3,3V – Fornece energia ao módulo e deve ser conectado ao pino 3,3V no ESP.
CS – O Pino CS (Slave Select) é utilizado pelo ESP32 para ativar e desativar dispositivos específicos junto ao barramento SPI.
MOSI – O pino MOSI (Master Out Slave In) é o pino de entrada SPI do Mini SD Card.
CLK – O Serial Clock é utilizado para sincronizar a transmissão de dados entre o ESP e o Módulo através dos pulsos de clock.
MISO – O pino MISO (Master In Slave Out) é o pino de saída SPI do Mini SD Card.
GND – Deve ser conectado ao terra do ESP.
Preparando o Cartão Micro SD
Antes de utilizarmos o Cartão Micro SD e inseri-lo no Módulo para comunicação junto ao ESP é necessário realizar a formatação do mesmo para os formatos FAT16 ou FAT32.
Caso tenha comprado um cartão SD recentemente é possível que este já esteja pré-formatado com um sistema de arquivo FAT, porém é recomendado que se faça a formatação assim mesmo, até se existir um cartão antigo que já esteja neste formato.
Para realizar a formatação do Cartão, recomenda-se a utilização do aplicativo oficial da Associação SD, disponível para Download AQUI.
Área de Trabalho do Software SD Card Formatter
Após formatar o cartão SD precisamos criar um arquivo txt para salvar os dados lidos pelo Sensor de Fluxo de Água e para ser aberto através do software para isto. Caso optássemos por criar um arquivo via código sempre que reiniciasse o sistema seria criado outro arquivo e consequentemente sobreposto.
Como criar um arquivo txt?
Para criar um arquivo txt, vamos entrar na pasta do cartão SD e ao clicarmos com o botão direito em qualquer lugar dentro da pasta iremos até o item Novo e ao lado em Documento de Texto como mostra na imagem abaixo.
Como criar arquivo txt do ESP32 Projeto com Sensor de Fluxo
Após isto e com o arquivo criado vamos alterar este para o mesmo nome citado no código Arduino, que no nosso caso é o seguinte:
Nome do Arquivo txt do ESP32 Projeto com Sensor de Fluxo
Com todos estes passos prontos, partimos para o desenvolvimento elétrico e posteriormente ao desenvolvimento do software do ESP32 Projeto com Sensor de Fluxo.
Produtos Utilizados no ESP32 Projeto Sensor de Fluxo
– NodeMCU ESP32 Iot com WiFi e Bluetooth – 38 Pinos;
– Sensor de Fluxo de Água G 1/2 1-30 l/min;
– Módulo Relógio Tempo Real RTC – DS1307;
– Mini SD Card Arduino / Mini Leitor Micro SD Card;
– Protoboard 830 pontos para montagem de projetos;
– Jumpers.
Esquema de Ligação do ESP32 Projeto com Sensor de Fluxo
O esquema de ligação do ESP32 Projeto com Sensor de Fluxo conta com a inclusão de um Mini SD Card e de um Módulo RTC. Lembrando que para a utilização do Mini SD Card é necessário também a inclusão de um Micro Cartão SD junto ao mesmo.
Vale diferenciar apenas a alimentação do Módulo RTC que deve ser feita através do pino 5V e os pinos de ambos os módulos que devem ser feitas nos específicos pinos de comunicação.
Esquema de Ligação ESP32 Projeto com Sensor de Fluxo
Com o esquema de ligação montado, chegou a hora de programarmos o ESP32 com o código desenvolvido abaixo.
Código de Funcionamento do ESP32 Projeto com Sensor de Fluxo
O código de funcionamento do ESP32 Projeto com Sensor de Fluxo foi projeto para realizar a verificação em tempo real do fluxo de líquidos e enviá-los via sistema WiFi para a tela do celular.
Com um sistema de funcionamento continuado e através do Módulo RTC, sempre chegar às 23:59:59 o valor total de água que passou pelo Sensor será gravado no Arquivo txt e será reinicializada a contagem.
Além de salvar os valores no cartão de memória, o valor total consumido por dia também será exibido na tela do dispositivo WiFi conectado. Porém vale ter cuidado com um detalhe, sempre que o ESP32 se reinicializar, os valores obtidos pela leitura do Sensor de Fluxo do dia em questão serão zerados.
O código completo do ESP32 Projeto com Sensor de Fluxo você encontra abaixo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 |
/************************************************************ -------------- Autor: Gustavo R Stroschon ----------------- ----------------- Data: 05/03/2020 ----------------------- ----------------- Função do programa: ----------------------- -Automatizar o monitoramento de consumo de agua pelo celular- *************************************************************/ #include <Wire.h> #include "RTClib.h" #include "FS.h" #include "SD.h" #include "SPI.h" #include <WiFi.h> #include <WiFiClient.h> #include <WiFiAP.h> void salvar_dados(); float MiliLitros = 0; // Defina o nome da rede e a senha a qual voce deseja gerar #define ssid "Sensor_de_Fluxo" #define password "12345678" WiFiServer server(80); RTC_DS1307 rtc; #define portaVazao GPIO_NUM_25 volatile int pulsos_vazao = 0; float vazao = 0; unsigned long ultimo_valor_salvo = 0; float vazao_somando; void IRAM_ATTR Interrupcao(void* arg) { // funçao chamada cada vez que o sensor de fluxo mandar um pulso pulsos_vazao++; //soma a variavel de contagem de pulsos do sensor de fluxo de agua portYIELD_FROM_ISR(); } void Configurar_interrupcao(gpio_num_t Port) { pinMode(portaVazao, INPUT_PULLUP); //configura pino como entrada gpio_set_intr_type(Port, GPIO_INTR_NEGEDGE); //tipo de interrupçao gpio_intr_enable(Port); //ativa a porta gpio_install_isr_service(0); //instala a interrupçao gpio_isr_handler_add(Port, Interrupcao, (void*) Port); // oque fazer ao detectar a interupçao } void setup() { Wire1.begin(); //inicia protocolo de comunicaçao rtc.begin();//inicia a comunicaçao com o rtc Serial.begin(115200); if (!SD.begin()) { // caso o cartao nao tenha iniciado Serial.println("Erro ao iniciar a comunicacao com o cartao SD..."); ESP.restart(); } DateTime now = rtc.now(); //cria um objeto com as informaçoes de data e hora Configurar_interrupcao((gpio_num_t) portaVazao); //chama a funçao que ira configurar a interrupçao Serial.println("Configurando o ponto de acesso wifi..."); // caso voce queira retirar o parametro de password sua rede ficara livre(sem senha para se conectar nela) WiFi.softAP(ssid, password); IPAddress myIP = WiFi.softAPIP(); Serial.print("O ip que voce deve digitar para acessar as informaçoes é : "); Serial.println(myIP); server.begin(); Serial.println(); Serial.println("Servidor iniciado com sucesso!!!"); } void loop() { salvar_dados(); //faz verificaçao e salvamento dos dados WiFiClient client = server.available(); // armazena as informacoes do cliente a qual se conectou a rede if (client) { // se alguem se conectar a rede Serial.println("Novo cliente conectado as informacoes sobre o fluxo da agua."); String currentLine = ""; // variavel com algumas informaçoes adicionais sobre o cliente while (client.connected()) { // enquando alguem estiver conectado... if (client.available()) { // e se ele carregar o ip char c = client.read(); if (c == '\n') { // quando carregar a pagina mostre.... if (currentLine.length() == 0) { salvar_dados(); // mande as informacoes abaixo para o navegador do cliente client.println("HTTP/1.1 200 OK"); client.println("Content-type:text/html"); client.println(); client.print("<p>O valor atual do consumo do dia em litros:"); client.print(vazao_somando); client.print("</p><br>"); client.print("<p> Os valores diarios estao abaixo: <br>"); Serial.printf("Lendo o arquivo: %s\n", "/Fluxo_de_agua.txt"); File file = SD.open("/Fluxo_de_agua_dia.txt"); // abre o arquivo para a leitura if (!file) { //caso o arquivo nao tenha sido iniciado ou aberto Serial.println("Erro ao abrir arquivo para a leitura"); } while (file.available()) { //se tiver dados pra ler... client.write(file.read()); //mostre ao navegador do cliente } file.close(); // fecha o arquivo client.print("</p><br>"); client.println(); break; // apos isso as informacoes ja foram enviadas , sai do laco while } else { // se a pagina for recarregada currentLine = ""; } } else if (c != '\r') { currentLine = ""; } } } // fecha a conexao client.stop(); Serial.println("Cliente desconectou."); } } void salvar_dados() { if ((millis() - ultimo_valor_salvo) > 1000) { // caso ja tenha passado 1 segundo do ultimo dado aferido e salvo ultimo_valor_salvo = millis(); DateTime now = rtc.now(); //guarda as informaçoes de data e tempo no objeto now //converte a quantia de pulsos que o sensor mandou para a vazao da agua em litros por minuto vazao = pulsos_vazao / 5.5; pulsos_vazao = 0; MiliLitros = vazao / 60; vazao_somando = vazao_somando + MiliLitros; // calcula a vazao total do dia if(now.hour() == 23 && now.minute() == 59 && now.second() == 59){ // caso ja seja 23:59:59 vamos salvar os dados no cartao sd Serial.println(" ---------------------------------- "); Serial.println(vazao_somando); Serial.println(" ---------------------------------- "); String dataMessage = String(now.day()) + "/" + String(now.month()) + "/" + String(now.year()) + " --- " + String(vazao_somando) + " L/dia <br> \n "; // cria a string que sera salva no cartao sd Serial.println(dataMessage); EditarArquivo(SD, "/Fluxo_de_agua_dia.txt", dataMessage.c_str()); vazao_somando = 0; // reinicia a contagem de vazao de agua diarios } // mostra o valor da leitura do sensor Serial.print(" Sensor de Vazao esta registrando "); Serial.print(MiliLitros); Serial.println(" litros/Segundo"); } } void EditarArquivo(fs::FS &fs, const char * local, const char * mensagem) { Serial.printf("editando o arquivo: %s\n", local); File file = fs.open(local, FILE_APPEND); if (!file) { Serial.println("Falha ao abrir o arquivo para editar"); return; } file.print(mensagem); file.close(); } |
Com o código acima, conseguimos então, realizar a leitura dos dados referentes ao sensor de fluxo e visualizá-los através de um IP junto ao Navegador. Para descobrirmos qual o IP específico iremos digitar no navegador seguiremos os seguintes passos:
Após conectar o ESP32 ao computador e gravarmos o código, iremos abrir o monitor serial e verificar que este estará exibindo valores dos litros por segundo que passam pelo sistema naquele exato momento, normalmente serão valores zerados.
Após, é necessário realizar um reset no ESP32 através do botão EN localizado em sua parte superior, por vezes irá aparecer o seguinte erro:
|
1 2 3 |
rst:0x1 (POWERON_RESET),boot:0x0 (DOWNLOAD_BOOT(UART0/UART1/SDIO_FEI_FEO_V2)) waiting for download |
Este é um erro de inicialização devido ao alto fluxo de dados, porém pode ser resolvido dando reset novamente junto ao ESP32 NodeMCU, com o êxito deste passo poderemos visualizar as seguinte informações:
Tela de inicialização do ESP32 Projeto com Sensor de Fluxo
Nesta tela podemos observar circulado o IP e o local o qual pode-se observá-lo. Com este link, iremos abrir o navegador e digitar no local de acesso do mesmo. Ao acessar o IP já teremos o retorno de fluxo total de líquidos que circulou no Sensor de Fluxo de Água desde a inicialização, veja um print da tela do navegador:
Tela do navegador com dados do Sensor de Fluxo
Agora basta ficar de olho nos dados e verificar o consumo de líquidos de sua residência em tempo real.
Conclusão
O ESP32 Projeto com Sensor de Fluxo é uma excelente solução para quem deseja monitorar a quantidade de água que se gasta em sua residência ou empresa diretamente do seu smartphone ou computador, evitando problemas de vazamento, gastos excessivos ou até mesmo a falta de água em sistemas hidráulicos.
Através do presente projetos muitas ações podem ser desenvolvidas, pode-se incluir uma relé para acionamento e desligamento de válvulas solenoides assim como também é possível acionar sistemas secundários de fornecimento de água caso esta acabe.
Não esqueça de deixar o seu comentário abaixo com as experiências obtidas no desenvolvimento deste projeto, suas dificuldades e melhorias desenvolvidas.
Olá, é possível realizar esse projeto no NodeMCU ESP8266?
Boa Tarde Camila! Infelizmente nunca realizei este mesmo projeto com o ESP8266, porém acredito que através das devidas adaptações, seja possível realizar sem problemas o projeto.
O sensor de fluxo é preciso, ou pode enganar contabilizando o ar que passa por ele?
Bom Dia Rogério! Infelizmente, caso tenha circulação de ar nos canos, este irá gerar imprecisões na verificação, uma vez que não consegue diferenciar.
Olá, para utilizar este circuito utilizando uma alimentação externa. Posso utilizar quantos volts na entrada VIN, utilizando o cabo conectado ao ESP, tudo funciona OK, mas quando eu o alimento com um 7805 através da porta VIN, ele tem problemas de conexão.
Boa Tarde Alisson! A alimentação via Vin do ESP32 deve ser feita com 5V, porém vale lembrar que além da alimentação, temos outro produto que também utiliza 5V para funcionar.
Parabéns pelo projeto!!!
Gostaria de saber, se seria possível acionar manualmente o dispositivo, para eu determinar o momento de leitura.
Podendo assim receber e gravar as informações de cada medição.
Bom Dia Gabriel! Tal incremento é possível através das devidas alterações no código e inclusão do dispositivo de acionamento, porém não tenho nada pronto neste momento que possa lhe auxiliar.
Quais os GPIOS utilizados para ligar o módulo RTC? O meu ESP32 tem uma pinagem diferente da mostrada na figura””Esquema de Ligação ESP32 Projeto com Sensor de Fluxo”.
Desde já agradeço a atenção! Ótimo tutorial!
Bom Dia Aislan! Existem dois modelos de ESP32, um de 30 pinos e outro de 38 pinos, existem algumas diferenças entre a pinagem dos mesmos, a pinagem completa do modelo utilizado neste projeto você encontra no link do produto que segue: https://www.usinainfo.com.br/nodemcu/nodemcu-esp32-iot-com-wifi-e-bluetooth-38-pinos-5346.html
Qual a pinagem utilizada na ligação entre o módulo SD e o ESP32?
Bom dia Aislan! O esquema de ligação com os pinos utilizados e a ligação completa você encontra neste mesmo link através do Subtítulo “Esquema de Ligação do ESP32 Projeto com Sensor de Fluxo”.
Olá poderia disponibilizar a lib wifiap.h não estou conseguindo encontrar na net.
Bom dia Josimar! Normalmente esta biblioteca vem incluída junto aos padrões de instalação do ESP32, porém você consegue encontrá-la através do seguinte link: https://github.com/espressif/arduino-esp32
Saudações
To apanhando na pinagem, o meu é 30 pinos estou tentando referenciar com o de 38 mas nao esta dando certo, vc poderia colocar a pinagem.
Obrigado.
Bom Dia Carlos! No link que segue, é possível encontrar o esquema de pinos do ESP32 38 Pinos, veja: https://www.usinainfo.com.br/blog/esp32-tutorial-com-primeiros-passos/
Boa tarde, quais seriam as entradas para usar essa mesma programação em um ESP32 LoRA? Teria como usar essa mesma programação em um esp32 LoRa?
Bom Dia Murilo! Existem diferentes modelos de ESP32 Lora, para cada um deles pode ser necessária alguma alteração diferente.
Bom dia boa tarde boa noite.
Quando eu abro o monitor serial aparecem vários caracteres aleatórios, tipo “??//&&55$$33@@#$%ˆ”
Voces sabem por que?
Obrigada
Olá Gabriela! É possível que o problema esteja na configuração do Baud Rate, normalmente determinamos um no código para estabelecer os parâmetros de comunicação e quando abrimos o monitor serial, o valor configurado deve ser o mesmo do código, que neste caso é 115200, elemento o qual pode verificar no monitor serial com a nomenclatura velocidade.
Excelente tutorial. Parabéns! Poderia substituir o sensor de água por um sensor de corrente não invasivo 100a Sct-013? Mediria energia? Tem algum link que mostre esta utilização? Obg.
Olá Jose! Infelizmente não desenvolvi nenhum projeto com este sensor de corrente até o momento, porém o incluirei em minha lista para trabalhar com ele em breve.
Boa noite, gostaria de saber se tem como controlar uma placa mp3 utilizando o ESP32 fazendo com que ao selecionar uma determinada função em um display touch automaticamente comece a tocar uma música já determinada
Olá Gustavo! É possível desenvolver um projeto semelhante a este com o ESP32, se torna um pouco mais complexo com a inclusão do display touch, mas com a devida programação e os dispositivos certos, acredito que seja possível desenvolver algo.
Olá parabéns pelo projeto, qual o nome do programa utilizado para esquematizar o circuito ?
Boa tarde Gabriel, o fritzing ou algum editor de imagem.
GOSTARIA DE SABER SE VOCE VENDE ESSE PROJETO MONTADO E JÁ PROGRAMADO?
Boa tarde Kaique, vendemos apenas os produtos de forma separada. Não trabalhamos com o desenvolvimento do projeto. Conheça nosso site em: http://www.usinainfo.com.br
Olá Daniel, muito boa essa aplicação, tenho um painel que usa hidrômetros, irei refazer utilizando o ESp32, parabéns.
Eu estava tentando fazer esse projeto e não consigo acesso a essas bibliotecas. Existe uma versão atualizada delas que possam ser utilizadas?
Opa Arthur, tudo bem?
Você pode instalar manualmente cada biblioteca pelo gerenciador de bibliotecas da Arduino IDE.
Na IDE mais comum você vai no menu de cima em: “Ferramentas -> Gerenciador de Biblioteca”.
Depois basta digitar o nome de cada biblioteca em “Refine sua busca…” e apertar enter, instalar uma por uma.
Já na nova IDE, no menu lateral no terceiro ícone abre o gerenciador de bibliotecas e basta pesquisar e instalar uma a uma.