IP esp8266 via webserver

Projects Programming
1

I'm trying to make a program where I enter data into an html form on a host server but I don't know what IP address to put in the form:

Obviously not the local ip. Where can I get this IP?
2

you may follow this tutorial:
ESP8266 NodeMCU Publish Sensor Readings to ThingSpeak (easiest way)

3

I followed this tutorial:

https://randomnerdtutorials.com/visualize-esp32-esp8266-sensor-readings-from-anywhere/

By the way, his are the best I've ever read!! The point is that I want to complement this tutorial to send, from html, information to esp. My previous post lacked information. Didn't realize it was missing...

<h2>Register New Temperature:</h2>
  <form action='ESP_IP' method='POST'>
  <label for='temperature'>Temperature (°C):</label>
  <input type='number' step='0.1' id='temperature' name='temperature' required><br><br>
  <label for='time'>Time (seconds):</label>
  <input type='number' id='time' name='time' required><br><br>
  <input type='submit' value='Register'>
  </form>

The idea is to send to esp temperatures and times to control relays. I've tried a lot. I read a lot. I saw many examples. But I still haven't figured out how to do that. I managed more or less to run esp as a web server but I've already noticed that the exchange of information between esp and html is complicated. There are constant crashes and a lot of delay in exchanging information. Also, for my project it's better to control on a web server.

The internal IP is:

192.xxx.xx.107

On the router I saw IP Lan:

192.xxx.xx.1

4

Why is ESP8266 not receiving this data?

<h2>Register New Temperature:</h2>
  <form action='/' method='POST'>
  <label for='temperature'>Temperature (°C):</label>
  <input type='number' step='0.1' id='temperature' name='temperature' required><br><br>
  <label for='time'>Time (seconds):</label>
  <input type='number' id='time' name='time' required><br><br>
  <input type='submit' value='Register'>
  </form>

The sketch:

void handleAddTemperature() {
  float temperature = server.arg("temperature").toFloat();
  unsigned long time = server.arg("time").toInt();

  Serial.print("Received temperature: ");
  Serial.println(temperature);
  Serial.print("Received time: ");
  Serial.println(time);

  if (numTemperatures < MAX_TEMPERATURES) {
    temperatureData[numTemperatures].temperature = temperature;
    temperatureData[numTemperatures].time = time;
    numTemperatures++;
    saveTemperatureData();
  }

  server.send(200, "text/html", "<script>window.location.href = '/';</script>");
}

The entire sketch

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <FS.h>
#include "secrets.h"

const char* ssid = STASSID;
const char* pass = STAPSK;

// Sensor de temperatura conectado na GPIO 4 / D2
#define ONE_WIRE_BUS 4

// Pinos do relê
#define HEATER_RELAY_PIN 5
#define COOLER_RELAY_PIN 4

// Hysteresis da temperatura
#define HYSTERESIS 0.4

// Web server
ESP8266WebServer server(80);

// Sensor de temperatura
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

// Temperaturas e tempos
struct TemperatureData {
  float temperature;
  unsigned long time;
};

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;
unsigned long remainingTime;
unsigned long elapsedTime;
unsigned long tempoFase;
unsigned long tempoAtual;
bool atualizaTarget = false;
bool contagemTempo = false;

  
// 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);
}

// Carregar dados de temperatura do arquivo
void loadTemperatureData() {
  if (SPIFFS.begin()) {
    if (SPIFFS.exists("/temperatures.txt")) {
      File file = SPIFFS.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();
      }
    }
    SPIFFS.end();
  }
}

// Salvar dados de temperatura em arquivo
void saveTemperatureData() {
  if (SPIFFS.begin()) {
    File file = SPIFFS.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();
    }
    SPIFFS.end();
  }
}

// Script da página html
void handleRootPage() {
  String html;

  if (SPIFFS.begin()) {
    File file = SPIFFS.open("/index.html", "r");
    if (file) {
      html = file.readString();
      file.close();
    }
    SPIFFS.end();
  }

  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 += "</li>";
  }

  html.replace("{{temperatures}}", temperaturesHtml);

  server.send(200, "text/html", html);
}

// Script para adicionar nova temperatura/tempo
void handleAddTemperature() {
  float temperature = server.arg("temperature").toFloat();
  unsigned long time = server.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();
  }

  server.send(200, "text/html", "<script>window.location.href = '/';</script>");
}

// Script para deletar temperature/tempo
void handleDeleteTemperature() {
  int index = server.arg("index").toInt();

  if (index >= 0 && index < numTemperatures) {
    for (int i = index; i < numTemperatures - 1; i++) {
      temperatureData[i] = temperatureData[i + 1];
    }
    numTemperatures--;
    saveTemperatureData();
  }

  server.sendHeader("Location", "/");
  server.send(303);
}

// Leitura da temperatura do sensor DS18B20
float readTemperature() {
  sensors.requestTemperatures();
  return sensors.getTempCByIndex(0);
}

// 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 basedo na temperatura corrente e temperatura alvo
void controlRelays(float currentTemperature, float targetTemperature) {
  static unsigned long lastCoolerOffTime = 0;
 
  bool heaterState = digitalRead(HEATER_RELAY_PIN);
  bool coolerState = digitalRead(COOLER_RELAY_PIN);

  if (currentTemperature < targetTemperature - HYSTERESIS) {
    digitalWrite(HEATER_RELAY_PIN, HIGH);
    heaterState = true;
    Serial.println("Aquecedor ligado");
    Serial.println("Temperatura alvo: ");
    Serial.println(targetTemperature);
    Serial.println("Tempo alvo: ");
    Serial.println(targetTime);
  } else if (currentTemperature > targetTemperature + HYSTERESIS) {
    if (!coolerState && millis() - lastCoolerOffTime >= 5 * 60 * 1000) {
      digitalWrite(COOLER_RELAY_PIN, HIGH);
      Serial.println("Geladeira ligada");
      coolerState = true;
    }
  }

  if (targetTemperature - HYSTERESIS <= currentTemperature && currentTemperature <= targetTemperature + HYSTERESIS && coolerState) {
    digitalWrite(COOLER_RELAY_PIN, LOW);
    Serial.println("Geladeira desligada");
    coolerState = false;
    lastCoolerOffTime = millis();
  }

  if (targetTemperature - HYSTERESIS <= currentTemperature && currentTemperature <= targetTemperature + HYSTERESIS && heaterState) {
    digitalWrite(HEATER_RELAY_PIN, LOW);
    Serial.println("Aquecedor desligado");
    heaterState = false;
  }
}

// Verifica se o processo de fermentatação está completo
bool isFermentationComplete() {
  return currentTemperatureIndex == numTemperatures;
}

// Recebe o comando para iniciar a fermentação alterando para true, que vai ser lido no loop
void handleStartTemperatureControl() {
  fermentationStarted = true;
  server.send(200, "text/plain", "Fermentação Iniciada");
}

// Envia para html indicação de fermentação completa
void handleFermentationComplete() {
  String html = "<html><head><title>Fermentação Concluída</title></head><body>";
  html += "<h1>Fermentação Concluída!</h1>";
  html += "<p>A fermentação atingiu todas as temperaturas alvo.</p>";
  html += "</body></html>";

  server.send(200, "text/html", html);
}

// Script de envio de dados de temperatura/tempo para o html
void handleTemperatureData() {
  float currentTemperature = readTemperature();
  float targetTemperature = temperatureData[currentTemperatureIndex].temperature;
  targetTime = temperatureData[currentTemperatureIndex].time;
  elapsedTime = millis() / 1000 - temperatureData[currentTemperatureIndex].time;
//  remainingTime = (temperatureData[currentTemperatureIndex].time > elapsedTime) ? temperatureData[currentTemperatureIndex].time - elapsedTime : 0;

  // Create JSON response
  String jsonResponse = "{";
  jsonResponse += "\"currentTemperature\": " + floatToString(currentTemperature, 2) + ",";
  jsonResponse += "\"targetTemperature\": " + floatToString(targetTemperature, 2) + ",";
  jsonResponse += "\"remainingTime\": " + String(remainingTime) + ",";
  jsonResponse += "\"targetTime\": " + String(targetTime);
  jsonResponse += "}";

  server.send(200, "application/json", jsonResponse);
}

void setup() {
  Serial.begin(115200);

  // Connecta ao Wi-Fi
  WiFi.begin(ssid, pass);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  Serial.println("Connected to WiFi");

  // Inicia o servidor web
  server.on("/", handleRootPage);
  server.on("/add", handleAddTemperature);
  server.on("/delete", handleDeleteTemperature);
  server.on("/HTTP_POST, temperature", handleTemperatureData);
  server.on("/start", handleStartTemperatureControl);
  server.begin();

  // Inicializa o sensor de temperatura
  sensors.begin();

  // Lê o arquivo de temperatura/tempo
  loadTemperatureData();

  // Inicializa os relays
  initializeRelays();

  // Seta o currentTemperatureIndex para 0 inicialmente
  currentTemperatureIndex = 0;
}

void loop() {
  server.handleClient();

  // Lê a temperatura atual
  float currentTemperature = readTemperature();

  // Controla o início e término da fermentação
  if (isFermentationComplete()) {
    handleFermentationComplete();
  } else if (fermentationStarted && currentTemperatureIndex < numTemperatures) {
    float targetTemperature = temperatureData[currentTemperatureIndex].temperature;
    controlRelays(currentTemperature, targetTemperature);

    if (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;
      Serial.println("Tempo alvo: ");
      Serial.println(targetTime);
      Serial.println("Tempo atual: ");
      Serial.println(tempoAtual);
      tempoFase = tempoAtual + targetTime;
      atualizaTarget = false;
      contagemTempo = true;
    }
      /*
    if (tempoFase > millis()/1000) {
      unsigned long elapsed = ((millis()/1000) - tempoAtual);
      unsigned long elapsedTime = (targetTime - elapsed);
      Serial.println("Tempo que passou: ");
      Serial.println(elapsed);
      Serial.println("Tempo restante: ");
      Serial.println(elapsedTime);
      Serial.println(contagemTempo);
    }

    if (elapsedTime <= 1 && contagemTempo == true) 
    {
      Serial.println("Tempo no alvo alcançado. Passando para a próxima etapa!");
      currentTemperatureIndex++;
      contagemTempo = false;
    }
*/
    if (tempoFase < (millis()/1000) && contagemTempo == true) {
      Serial.println("Tempo no alvo alcançado. Passando para a próxima etapa!");
      currentTemperatureIndex++;
      contagemTempo = false;
    }
    
    }
  delay(500);
  }
5

you are sending your data to your root document but on the server your

void handleRootPage() {

doesn't read any parameters (arg, args, hasArg,...)

6

Duplicate post here: IP esp8266 via webserverhere.

7

@mvrinaldi, please do not cross-post. Threads merged.

8

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.