Esse projeto tem a finalidade de realizar a leitura do consumo de gás. Utilizando na implantação placas Wemos Lolin32 Lite, que conectadas a sensores ReedSwitch enviam os pulsos atraves do Google script para uma planilha. Na bancada o sistema esta funcionando perfeitamente pois estou utilizando para simular os sensores, 1 jumpers, que ao conecta-lo ao pino INPUT ao GNV envia os dados desejados. O Problema ocorre quando você conecta um jumper no pino INPUT, esse simples ato faz com que sejam enviados dados falsos para o google script, ou seja, emiti dados sem parar, mesmo não tendo sido fechado o circuito do sensor. Se utilizamos o INPU_PULLUP ou PULLDOWN, ele não envia dado algum, nem o real. Ai to com uma ferramente util, porém muito geniosa.
Sem mostrares o código que tens não dá para te dizermos o problema... eu consigo imaginar já dois mas com a informação que deste não posso ter a certeza.
Isso pode está ocorrendo porque o jumper esteja dando ruído. Pesquise pela função de Interrupção, creio que lhe ajudará. No canal do YouTube, Brincando com Ideias, tem um vídeo bem didática sobre interrupção em no Arduíno. Ai é só adaptar para o Wemos se for necessário.
Reforço o conselho do @bubulindo.
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <WiFiServer.h>
#include <WiFiClient.h>
#include <HTTPClient.h>
#include <ArduinoOTA.h>
#include <LittleFS.h>
#include <EEPROM.h>
// Configurações de rede WiFi
const char* SSID_Principal_2G = "XXXXX_2G";
const char* PASSWORD_Principal = "XXXXXXXXXX";
// Configurações do servidor Telnet
WiFiServer server(22); // Porta para Telnet
WiFiClient client;
// URL do Google Script
const char* googleScriptURL = "https://script.google.com/macros/s/xxxxxxxxxx/exec";
// Configurações do sensor
const int pinoSensor = 5; //ligação do reedswitch pino 5 e 3v
const char* idSensor = "ALB603";
WiFiClientSecure secureClient;
HTTPClient http;
bool estadoAnterior = HIGH;
bool estadoConfirmado = HIGH;
int valorAtual = 7854;
unsigned long previousMillis = 0;
const long interval = 50;
unsigned long tempoInicioPulso = 0;
unsigned long duracaoPulso = 0;
unsigned long tempoUltimaMudanca = 0;
const unsigned long tempoConfirmacao = 45;
void configurarOTA();
void enviarDadosParaGoogleScript(const char* id, int valorAtual);
void salvarDadosLocalmente(const char* id, int valorAtual);
void enviarDadosSalvos();
String urlEncode(const char* msg);
void conectarWiFi() {
Serial.println("Conectando às redes WiFi VALDIR...");
WiFi.begin(SSID_Principal_2G, PASSWORD_Principal);
int tentativas = 0;
while (WiFi.status() != WL_CONNECTED && tentativas < 30) {
Serial.print("Tentativa ");
Serial.print(tentativas);
Serial.print(" - Status WiFi: ");
Serial.println(WiFi.status());
delay(1000);
tentativas++;
}
if (WiFi.status() == WL_CONNECTED) {
Serial.println("\nWiFi conectado com sucesso!");
Serial.print("Endereço IP: ");
Serial.println(WiFi.localIP());
} else {
Serial.println("\nErro ao conectar ao WiFi");
ESP.restart();
}
}
void reconectarWiFi() {
if (WiFi.status() != WL_CONNECTED) {
Serial.println("WiFi desconectado, tentando reconectar...");
conectarWiFi();
}
}
void setup() {
Serial.begin(115200);
if (!LittleFS.begin()) {
Serial.println("Falha ao montar o sistema de arquivos. Tentando formatar...");
if (LittleFS.format()) {
Serial.println("Sistema de arquivos formatado com sucesso.");
if (!LittleFS.begin()) {
Serial.println("Erro: Não foi possível montar o sistema mesmo após a formatação.");
ESP.restart();
}
} else {
Serial.println("Erro: Formatação do LittleFS falhou.");
ESP.restart();
}
}
pinMode(pinoSensor, INPUT);
WiFi.setSleep(WIFI_PS_NONE);
WiFi.setAutoReconnect(true);
conectarWiFi();
server.begin();
Serial.println("Servidor Telnet iniciado na porta 22!");
configurarOTA();
EEPROM.begin(512);
}
void loop() {
ArduinoOTA.handle();
reconectarWiFi();
if (server.hasClient()) {
if (client && client.connected()) {
client.stop();
Serial.println("Conexão Telnet anterior encerrada.");
}
client = server.available();
client.println("Conexão Telnet estabelecida com sucesso!");
Serial.println("Novo cliente conectado via Telnet.");
}
if (client && client.connected()) {
while (client.available()) {
char c = client.read();
Serial.write(c);
Serial.print("Recebido do cliente Telnet: ");
Serial.println(c);
}
}
if (Serial.available()) {
while (Serial.available()) {
char c = Serial.read();
client.write(c);
Serial.print("Enviado para o cliente Telnet: ");
Serial.println(c);
}
}
bool leituraAtual = digitalRead(pinoSensor);
if (leituraAtual != estadoConfirmado) {
if (millis() - tempoUltimaMudanca >= tempoConfirmacao) {
estadoConfirmado = leituraAtual;
tempoUltimaMudanca = millis();
if (estadoConfirmado == LOW && estadoAnterior == HIGH) {
tempoInicioPulso = micros();
estadoAnterior = LOW;
Serial.println("Mudança confirmada: HIGH -> LOW (Campo magnético ausente)");
} else if (estadoConfirmado == HIGH && estadoAnterior == LOW) {
duracaoPulso = micros() - tempoInicioPulso;
estadoAnterior = HIGH;
if (duracaoPulso >= 35000 && duracaoPulso <= 45000) {
Serial.print("Ruído ignorado: Pulso com ");
Serial.print(duracaoPulso / 1000);
Serial.println(" ms.");
} else {
valorAtual += 1;
Serial.print("Pulso válido detectado! Duração: ");
Serial.print(duracaoPulso / 1000);
Serial.println(" ms");
Serial.print("Valor atual: ");
Serial.println(valorAtual);
enviarDadosParaGoogleScript(idSensor, valorAtual);
salvarDadosLocalmente(idSensor, valorAtual);
}
Serial.println("Mudança confirmada: LOW -> HIGH (Campo magnético presente)");
}
}
} else {
tempoUltimaMudanca = millis();
}
delay(5);
}
void configurarOTA() {
ArduinoOTA.setHostname("ESP32-OTA");
ArduinoOTA.setPassword("Cram25102024");
ArduinoOTA.onStart( {
String type = (ArduinoOTA.getCommand() == U_FLASH) ? "sketch" : "filesystem";
Serial.println("Iniciando atualização " + type);
});
ArduinoOTA.onEnd( {
Serial.println("\nAtualização concluída");
ESP.restart();
});
ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
Serial.printf("Progresso: %u%%\r", (progress / (total / 100)));
});
ArduinoOTA.onError([](ota_error_t error) {
Serial.printf("Erro [%u]: ", error);
if (error == OTA_AUTH_ERROR) Serial.println("Falha na autenticação");
else if (error == OTA_BEGIN_ERROR) Serial.println("Falha ao iniciar");
else if (error == OTA_CONNECT_ERROR) Serial.println("Falha na finalização");
});
ArduinoOTA.begin();
}
void enviarDadosParaGoogleScript(const char* id, int valorAtual) {
if (WiFi.status() != WL_CONNECTED) {
Serial.println("Erro: WiFi desconectado.");
return;
}
String url = String(googleScriptURL) + "?id=" + urlEncode(id) + "&valorAtual=" + String(valorAtual);
Serial.println("URL gerada: " + url);
secureClient.setInsecure();
secureClient.setTimeout(20000);
Serial.println("Configuração do cliente seguro feita.");
http.begin(secureClient, url);
Serial.println("Início da conexão HTTP.");
http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
Serial.println("Configuração de redirecionamento definida.");
Serial.println("Antes da solicitação HTTP GET.");
int httpCode = http.GET();
Serial.println("Depois da solicitação HTTP GET.");
Serial.print("HTTP GET código: ");
Serial.println(httpCode);
if (httpCode > 0) {
Serial.println("Código de resposta HTTP: " + String(httpCode));
String response = http.getString();
Serial.println("Resposta do servidor: " + response);
} else {
Serial.println("Erro ao enviar dados. Código de erro: " + String(httpCode));
Serial.print("Erro: ");
Serial.println(http.errorToString(httpCode).c_str());
}
http.end();
Serial.println("Fim da conexão HTTP.");
}
void salvarDadosLocalmente(const char* id, int valorAtual) {
EEPROM.write(0, 1);
int idSize = strlen(id);
String valorStr = String(valorAtual);
int valorSize = valorStr.length();
for (int i = 0; i < idSize && i < 20; i++) {
EEPROM.write(1 + i, id[i]);
}
for (int i = 0; i < valorSize && i < 20; i++) {
EEPROM.write(21 + i, valorStr[i]);
}
EEPROM.commit();
}
void enviarDadosSalvos() {
char id[20], valorStr[20];
for (int i = 0; i < 20; i++) {
id[i] = EEPROM.read(1 + i);
valorStr[i] = EEPROM.read(21 + i);
}
int valorAtual = atoi(valorStr);
enviarDadosParaGoogleScript(id, valorAtual);
}
String urlEncode(const char* msg) {
String encodedMsg = "";
while (*msg != '\0') {
if (('a' <= *msg && *msg <= 'z') || ('A' <= *msg && *msg <= 'Z') || ('0' <= *msg && *msg <= '9') || *msg == '/' || *msg == ':') {
encodedMsg += *msg;
} else {
encodedMsg += '%';
encodedMsg += String((unsigned char)*msg, HEX);
}
msg++;
}
return encodedMsg;
}
Obrigado, aparentemente consegui resolver o problema mudando a conexão de um dos fios do sensor do GNV para o 3v, e adicionei uma rotina que seleciona os pulsos pois constatei que os pulsos de ruído tem frequência em torno de 40ms enquanto o pulso real tem frequencia alta, acima de 35000ms e acrescentei um tempo para confirmação do pulso. aparentemente esta funcionando como devia, agora o quebra cabeça é verificar se o reedswitch esta funcionando como deve, uma vea que os testes que fiz foram simulados com o uso de jumpers um no pino 5 e outro no 3v, a ao conctar uma ao outro exerce as funções do reedswitch, que é um mero interruptor