Guys... is there any way to find out what could be causing the memory allocation problem (error like: "3fffefd0: feefeffe feefeffe feefeffe feefeffe")?
This is the entire sketch:
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include "LittleFS.h"
#include <Arduino_JSON.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include "secrets.h"
const char* ssid = STASSID;
const char* pass = STAPSK;
// Create AsyncWebServer object on port 80
AsyncWebServer server(80);
// Create a WebSocket object
AsyncWebSocket ws("/ws");
// Json Variable to Hold Sensor Readings
JSONVar readings;
// Sensor de temperatura conectado na GPIO 4 / D2
#define ONE_WIRE_BUS 4
// Pinos do relê
#define HEATER_RELAY_PIN D1
#define COOLER_RELAY_PIN D0
// Hysteresis da temperatura
#define HYSTERESIS 0.4
// Sensor de temperatura
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
// Temperaturas e tempos
struct TemperatureData {
float temperature;
unsigned long time;
};
// Function prototype declaration
unsigned long countElapsedTime();
const int MAX_TEMPERATURES = 15; // Limite de 15 passos
TemperatureData temperatureData[MAX_TEMPERATURES];
int numTemperatures = 0;
int currentTemperatureIndex = 0;
bool fermentationStarted = false;
unsigned long targetTime = 0;
unsigned long tempoFase = 0;
unsigned long tempoAtual = 0;
bool atualizaTarget = false;
bool contagemTempo = false;
unsigned long remainingTime = 0;
float targetTemperature = 0;
String formattedElapsedTime;
String formattedtargetTime;
const int MAX_WIFI_CONNECTION_ATTEMPTS = 5;
static bool heaterState = false;
static bool coolerState = false;
static unsigned long lastCoolerOffTime = 0;
// Variáveis que definem quanto tempo entre envios ao cliente
unsigned long lastTime = 0;
unsigned long timerDelay = 1000;
// Função auxiliar para converter float em string com determinada precisão
String floatToString(float value, int precision) {
char buffer[20];
sprintf(buffer, "%.*f", precision, value);
return String(buffer);
}
// Initializa WiFi
void initWiFi() {
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, pass);
Serial.print("Conectando ao WiFi ..");
while (WiFi.status() != WL_CONNECTED) {
Serial.print('.');
delay(1000);
}
Serial.println("Conectado!");
Serial.println(WiFi.localIP());
}
// Initializa LittleFS
void initFS() {
if (!LittleFS.begin()) {
Serial.println("An error has occurred while mounting LittleFS");
}
else{
Serial.println("LittleFS mounted successfully");
}
}
// Carregar dados de temperatura do arquivo
void loadTemperatureData() {
if (LittleFS.exists("/temperatures.txt")) {
File file = LittleFS.open("/temperatures.txt", "r");
if (file) {
numTemperatures = 0;
while (file.available() && numTemperatures < MAX_TEMPERATURES) {
String line = file.readStringUntil('\n');
int separatorIndex = line.indexOf(',');
if (separatorIndex != -1) {
temperatureData[numTemperatures].temperature = line.substring(0, separatorIndex).toFloat();
temperatureData[numTemperatures].time = line.substring(separatorIndex + 1).toInt();
numTemperatures++;
}
}
file.close();
}
}
}
// Salvar dados de temperatura em arquivo
void saveTemperatureData() {
File file = LittleFS.open("/temperatures.txt", "w");
if (file) {
for (int i = 0; i < numTemperatures; i++) {
file.println(floatToString(temperatureData[i].temperature, 2) + "," + String(temperatureData[i].time));
}
file.close();
}
}
// Função para ler a temperatura com tratamento de erro
float readTemperature() {
sensors.requestTemperatures();
float temperature = sensors.getTempCByIndex(0);
if (temperature == DEVICE_DISCONNECTED_C || temperature == 85.0) {
Serial.println("Falha na leitura do sensor de temperatura");
}
return temperature;
}
void convertTime(unsigned long timeInSeconds, unsigned int &days, unsigned int &hours, unsigned int &minutes, unsigned int &seconds) {
days = timeInSeconds / 86400;
timeInSeconds %= 86400;
hours = timeInSeconds / 3600;
timeInSeconds %= 3600;
minutes = timeInSeconds / 60;
seconds = timeInSeconds % 60;
}
unsigned long countElapsedTime() {
if (contagemTempo) {
unsigned long tempo = millis() / 1000 - tempoAtual;
return tempo >= targetTime ? 0 : targetTime - tempo;
} else {
return 0;
}
}
String getSensorReadings(){
float currentTemperature = readTemperature();
float targetTemperature = temperatureData[currentTemperatureIndex].temperature;
targetTime = temperatureData[currentTemperatureIndex].time;
remainingTime = countElapsedTime(); // Calculate the elapsed time
// Converta o tempo decorrido em uma string formatada (dias (dias) hh:mm:ss)
unsigned int days, hours, minutes, seconds;
convertTime(remainingTime, days, hours, minutes, seconds);
String formattedElapsedTime = String(days) + " (dias) " +
(hours < 10 ? "0" + String(hours) : String(hours)) + ":" +
(minutes < 10 ? "0" + String(minutes) : String(minutes)) + ":" +
(seconds < 10 ? "0" + String(seconds) : String(seconds));
// Converta o tempo alvo em uma string formatada (dias (dias) hh:mm:ss)
convertTime(targetTime, days, hours, minutes, seconds);
String formattedTargetTime = String(days) + " (dias) " +
(hours < 10 ? "0" + String(hours) : String(hours)) + ":" +
(minutes < 10 ? "0" + String(minutes) : String(minutes)) + ":" +
(seconds < 10 ? "0" + String(seconds) : String(seconds));
// Criar resposta JSON
String jsonResponse = "{";
jsonResponse += "\"currentTemperature\": " + String(currentTemperature, 2) + ",";
jsonResponse += "\"targetTemperature\": " + String(targetTemperature, 2) + ",";
jsonResponse += "\"formattedTargetTime\": \"" + formattedTargetTime + "\",";
jsonResponse += "\"formattedElapsedTime\": \"" + formattedElapsedTime + "\"";
jsonResponse += "}";
return jsonResponse;
}
void notifyClients(String sensorReadings) {
ws.textAll(sensorReadings);
}
void handleWebSocketMessage(void *arg, uint8_t *data, size_t len) {
AwsFrameInfo *info = (AwsFrameInfo*)arg;
if (info->final && info->index == 0 && info->len == len && info->opcode == WS_TEXT) {
String sensorReadings = getSensorReadings();
notifyClients(sensorReadings);
}
}
void onEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type, void *arg, uint8_t *data, size_t len) {
switch (type) {
case WS_EVT_CONNECT:
break;
case WS_EVT_DISCONNECT:
break;
case WS_EVT_DATA:
handleWebSocketMessage(arg, data, len);
break;
case WS_EVT_PONG:
case WS_EVT_ERROR:
break;
}
}
void initWebSocket() {
ws.onEvent(onEvent);
server.addHandler(&ws);
}
// Initialização dos relays
void initializeRelays() {
pinMode(HEATER_RELAY_PIN, OUTPUT);
digitalWrite(HEATER_RELAY_PIN, LOW);
pinMode(COOLER_RELAY_PIN, OUTPUT);
digitalWrite(COOLER_RELAY_PIN, LOW);
}
// Controle dos relays baseado na temperatura corrente e temperatura alvo
void controlRelays(float currentTemperature, float targetTemperature) {
static unsigned long lastCoolerOffTime = 999999; // Valor grande para garantir que millis() - lastCoolerOffTime >= 5 * 60 * 1000 no início
if (currentTemperature < targetTemperature - HYSTERESIS) {
digitalWrite(HEATER_RELAY_PIN, HIGH);
heaterState = true;
Serial.println("Aquecedor ligado");
}
if (coolerState == false && currentTemperature > targetTemperature + HYSTERESIS) {
digitalWrite(COOLER_RELAY_PIN, HIGH);
coolerState = true; // Define a variável como true para evitar ligar a geladeira repetidamente
Serial.println("Geladeira ligada");
}
if (targetTemperature - HYSTERESIS <= currentTemperature && currentTemperature <= targetTemperature + HYSTERESIS && coolerState) {
digitalWrite(COOLER_RELAY_PIN, LOW);
lastCoolerOffTime = millis();
Serial.println("Geladeira desligada");
}
// Verifica se já passou o tempo de espera após desligar a geladeira
if (coolerState && millis() - lastCoolerOffTime >= 5 * 60 * 1000) {
coolerState = false; // Define a variável como false para permitir ligar a geladeira novamente no futuro
}
if (targetTemperature - HYSTERESIS <= currentTemperature && currentTemperature <= targetTemperature + HYSTERESIS && heaterState) {
digitalWrite(HEATER_RELAY_PIN, LOW);
heaterState = false;
Serial.println("Aquecedor desligado");
}
}
// Verifica se o processo de fermentatação está completo
bool isFermentationComplete() {
return currentTemperatureIndex == numTemperatures;
}
// Função para configurar o servidor web
void configureWebServer() {
// Rota para a página inicial
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
// Montar a página HTML dinamicamente com os dados de temperatura
String html;
File file = LittleFS.open("/index.html", "r");
if (file) {
html = file.readString();
file.close();
}
String temperaturesHtml = "";
for (int i = 0; i < numTemperatures; i++) {
temperaturesHtml += "<li>";
temperaturesHtml += "Temperatura: " + floatToString(temperatureData[i].temperature, 2) + " °C, ";
temperaturesHtml += "Tempo: " + String(temperatureData[i].time) + " segundos";
temperaturesHtml += " [<a href='/delete?index=" + String(i) + "'>Deletar</a>]";
temperaturesHtml += " [<a href='/edit?index=" + String(i) + "'>Editar</a>]";
temperaturesHtml += "</li>";
}
html.replace("{{temperatures}}", temperaturesHtml);
// Enviar a página HTML como resposta ao cliente
request->send(200, "text/html", html);
});
// Rota para a página de edição
server.on("/edit", HTTP_GET, [](AsyncWebServerRequest *request) {
int index = request->arg("index").toInt();
if (index >= 0 && index < numTemperatures) {
// Montar a página de edição com o formulário
String html = "<html><head><title>Editar Temperatura</title></head><body>";
html += "<h1>Editar Temperatura</h1>";
html += "<form action='/update' method='POST'>";
html += "<input type='hidden' name='index' value='" + String(index) + "'>";
html += "Temperatura: <input type='text' name='temperature' value='" + floatToString(temperatureData[index].temperature, 2) + "'><br>";
html += "Tempo: <input type='text' name='time' value='" + String(temperatureData[index].time) + "'><br>";
html += "<input type='submit' value='Salvar'>";
html += "</form>";
html += "</body></html>";
// Enviar a página de edição como resposta ao cliente
request->send(200, "text/html", html);
} else {
// Índice inválido, enviar resposta de erro
request->send(404);
}
});
// Rota para o tratamento de atualização da temperatura
server.on("/update", HTTP_POST, [](AsyncWebServerRequest *request) {
int index = request->arg("index").toInt();
float newTemperature = request->arg("temperature").toFloat();
int newTime = request->arg("time").toInt();
String html;
if (index >= 0 && index < numTemperatures) {
temperatureData[index].temperature = newTemperature;
temperatureData[index].time = newTime;
saveTemperatureData();
request->send(200, "text/html", html);
request->send(303);
} else {
request->send(404, "text/plain", "Índice inválido");
}
});
// Rota para o tratamento de adicionar nova temperatura/tempo
server.on("/add", HTTP_POST, [](AsyncWebServerRequest *request) {
float temperature = request->arg("temperature").toFloat();
unsigned long time = request->arg("time").toInt();
Serial.print("Temperatura recebida: ");
Serial.println(temperature);
Serial.print("Tempo recebido: ");
Serial.println(time);
if (numTemperatures < MAX_TEMPERATURES) {
temperatureData[numTemperatures].temperature = temperature;
temperatureData[numTemperatures].time = time;
numTemperatures++;
saveTemperatureData();
}
request->send(200, "text/html", "<script>window.location.href = '/';</script>");
});
// Rota para o tratamento de deletar temperatura/tempo
server.on("/delete", HTTP_GET, [](AsyncWebServerRequest *request) {
int index = request->arg("index").toInt();
Serial.print("Deletar o cadastro: ");
Serial.println(index);
if (index >= 0 && index < numTemperatures) {
for (int i = index; i < numTemperatures - 1; i++) {
temperatureData[i] = temperatureData[i + 1];
}
numTemperatures--;
saveTemperatureData();
}
request->send(200, "text/plain", "/");
request->send(303);
});
// Rota para o tratamento de iniciar a fermentação
server.on("/start", HTTP_GET, [](AsyncWebServerRequest *request) {
fermentationStarted = true;
Serial.println("Fermentação Iniciada");
request->send(200, "text/plain", "Fermentação Iniciada");
});
}
void setup() {
Serial.begin(115200);
initWiFi();
initFS();
initWebSocket();
// Inicializa o sensor de temperatura
sensors.begin();
// Configuração do servidor web
configureWebServer();
// Lê o arquivo de temperatura/tempo
loadTemperatureData();
// Inicializa os relays
initializeRelays();
// Seta o currentTemperatureIndex para 0 inicialmente
currentTemperatureIndex = 0;
// Web Server Root URL
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
request->send(LittleFS, "/index.html", "text/html");
});
server.serveStatic("/", LittleFS, "/");
// Iniciar o servidor web
server.begin();
}
void loop() {
if ((millis() - lastTime) > timerDelay) {
String sensorReadings = getSensorReadings();
notifyClients(sensorReadings);
lastTime = millis();
}
ws.cleanupClients();
// Lê a temperatura atual
float currentTemperature = readTemperature();
Serial.println(currentTemperature);
// Controla o início e término da fermentação
if (isFermentationComplete()) {
Serial.println("Fermentação completa");
notifyClients("Fermentação Concluída!"); // Envia a mensagem para todos os clientes conectados através do WebSocket
} else if (fermentationStarted && currentTemperatureIndex < numTemperatures) {
float targetTemperature = temperatureData[currentTemperatureIndex].temperature;
controlRelays(currentTemperature, targetTemperature);
notifyClients("Fermentação Iniciada!"); // Envia a mensagem para todos os clientes conectados através do WebSocket
}
if (contagemTempo == false && currentTemperature >= targetTemperature - HYSTERESIS && currentTemperature <= targetTemperature + HYSTERESIS) {
Serial.println("Temperatura alvo atingida! Início da contagem do tempo!");
atualizaTarget = true;
}
if (atualizaTarget == true) {
tempoAtual = millis() / 1000;
tempoFase = tempoAtual + (targetTime / 1000); // Assuming targetTime is in milliseconds
atualizaTarget = false;
contagemTempo = true;
}
if (tempoFase < (millis() / 1000) && contagemTempo == true) {
Serial.println("Tempo no alvo alcançado. Passando para a próxima etapa!");
currentTemperatureIndex++;
contagemTempo = false;
}
}