/*#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>

const char* ssid = "Sol 17_5G";
const char* password = "221615sr";
const char* mqtt_server = "Endereço IP do servidor MQTT";
const char* mqtt_user = "Nome de usuário MQTT";
const char* mqtt_password = "Senha MQTT";
const int mqtt_port = 1883;
const char* mqtt_topic = "topico/temperatura";

const int DHT_PIN = 4; // Pino de dados do sensor DHT22
const int BUFFER_SIZE = 10; // Tamanho do buffer circular
float tempBuffer[BUFFER_SIZE]; // Buffer circular para armazenar as leituras de temperatura
int bufferIndex = 0; // Índice do buffer circular
float tempSum = 0; // Soma das leituras de temperatura para calcular a média móvel

WiFiClient espClient;
PubSubClient client(espClient);
DHT dht(DHT_PIN, DHT22);

void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Conectando-se a ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("Conectado à rede Wi-Fi");
  Serial.println("Endereço IP: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) {
  // Lidar com mensagens recebidas, se necessário
}

void reconnect() {
  while (!client.connected()) {
    Serial.print("Conectando ao broker MQTT...");
    if (client.connect("ESP32Client", mqtt_user, mqtt_password)) {
      Serial.println("Conectado!");
    } else {
      Serial.print("Falha na conexão, rc=");
      Serial.print(client.state());
      Serial.println(" Tentando novamente em 5 segundos");
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  dht.begin();
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  float temperature = dht.readTemperature(); // Ler a temperatura do sensor DHT22
  if (!isnan(temperature)) {
    tempSum -= tempBuffer[bufferIndex]; // Remover a leitura mais antiga do buffer
    tempBuffer[bufferIndex] = temperature; // Adicionar a nova leitura ao buffer
    tempSum += temperature; // Adicionar a nova leitura à soma
    bufferIndex = (bufferIndex + 1) % BUFFER_SIZE; // Atualizar o índice do buffer circular

    float averageTemp = tempSum / BUFFER_SIZE; // Calcular a média móvel

    Serial.print("Temperatura média: ");
    Serial.println(averageTemp);

    // Enviar a temperatura para o servidor MQTT
    char tempStr[10];
    sprintf(tempStr, "%.2f", averageTemp);
    client.publish(mqtt_topic, tempStr);
  }

  delay(5000); // Aguardar 5 segundos antes de enviar a próxima leitura
}*/

//---------------------------------------------

/*#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h>
#include <DHTesp.h>
#include <DHT22.h>
#include <DHT.h>
#include <ESPAsyncWebServer.h>
#include <LiquidCrystal_I2C.h>

#ifndef WEBPAGE_H_
#define WEBPAGE_H_

#define I2C_ADDR    0x27
#define LCD_COLUMNS 16
#define LCD_LINES   2

const int DHT_PIN = 15;

DHTesp dhtSensor;

LiquidCrystal_I2C lcd(I2C_ADDR, LCD_COLUMNS, LCD_LINES);

// Configurações do Wi-Fi
const char* ssid = "Wokwi-GUEST";
const char* password = "";

// Configurações do MQTT
const char* mqtt_server = "test.mosquitto.org";
const char* mqtt_topic = "temperatura";

// Configurações do sensor DHT22

#define DHTPIN 15
#define DHTTYPE DHT22

// Buffer circular para média móvel
const int bufferSize = 10;
float temperatureBuffer[bufferSize];
int bufferIndex = 0;

// Inicialização do cliente MQTT
WiFiClient espClient;
PubSubClient client(espClient);

// Configuração do servidor web
AsyncWebServer server(80);

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

  // Conecta-se à rede Wi-Fi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Conectando ao Wi-Fi...");
  }
  Serial.println("Conectado ao Wi-Fi!");

  // Configurações do cliente MQTT
  client.setServer(mqtt_server, 1883);

  // Rota para a página web
  server.on("/", HTTP_GET, {
    String html = "<html><body>";
    html += "<h1>Temperatura:</h1>";
    html += "<p>" + String(getAverageTemperature()) + " °C</p>";
    html += "</body></html>";
    request->send(200, "text/html", html);
  });

  // Inicia o servidor web
  server.begin();
}

void loop() {
  // Leitura da temperatura
  float temperature = dht.readTemperature();

  // Adiciona a temperatura ao buffer circular
  temperatureBuffer[bufferIndex] = temperature;
  bufferIndex = (bufferIndex + 1) % bufferSize;

  // Calcula a média móvel
  float averageTemperature = getAverageTemperature();

  // Publica a temperatura via MQTT
  if (client.connected()) {
    String payload = String(averageTemperature);
    client.publish(mqtt_topic, payload.c_str());
  }

  delay(10000); // Intervalo de leitura (10 segundos)
}

float getAverageTemperature() {
  float averageTemperature = 0;
  for (int i = 0; i < bufferSize; i++) {
    averageTemperature += temperatureBuffer[i];
  }
  return averageTemperature / bufferSize;
}

void reconnect() {
  while (!client.connected()) {
    if (client.connect("ESP32Client")) {
      Serial.println("Conectado ao broker MQTT!");
    } else {
      delay(1000);
    }
  }
}

#endif WEBPAGE_H_*/

//---------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h>
#include <DHTesp.h>
#include <DHT22.h>
#include <DHT.h>
#include <ESPAsyncWebServer.h>
#include <LiquidCrystal_I2C.h>

struct ringBuffer 
{
    void *bufferData;
    int head;
    int tail;
    int size;
    int numElements;
};

void bufferInitialization(struct ringBuffer *buffer, int size) 
{
    buffer->size = size;
    buffer->head = 0;
    buffer->tail = 0;
    buffer->numElements = 0;
    buffer->bufferData = (void*)malloc(sizeof(int)*size);
}

void bufferFree(struct ringBuffer *buffer)
{
    free(buffer->bufferData);
}

int pushBack(struct ringBuffer *buffer, int *data)
{

    /*  int i;
    i = buffer->head + buffer->tail + 1;
    if (i >= buffer->size) 
    {
        i = 0;
    }
    buffer->bufferData[i] = data;*/
    memcpy((void*)buffer->head, data, buffer->size);
    buffer->head = buffer->head + buffer->size;
    if (buffer->head == buffer->tail)
    { 
        buffer->head = (int)buffer->bufferData; //error?
    }
    buffer->numElements++;
    return 0;
}

int popFront(struct ringBuffer *buffer, void *data)
{
    //void * bufferData;

    /*bufferData = buffer->bufferData[buffer->head];
    buffer->head++;
    buffer->tail--;
    if (buffer->head == buffer->size) 
    {
        buffer->head = 0;
    }
    //return bufferData;*/

    memcpy(data, (void*)buffer->tail, buffer->size); //error?
    buffer->tail = buffer->tail + buffer->size;

    if ((void*)buffer->tail == buffer->bufferData)
    { 
        buffer->tail = (int)buffer->bufferData; //error?
    }
    buffer->numElements--;
    return 0;
}

int main() 
{
    struct ringBuffer buffer;
    int size = 5;
    //*buffer->size = 6;
    bufferInitialization(&buffer, size);
    char *data[] = { "1" , "2", "3", "4" , "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20" };

    for (int i = 0; i < size; i++)
    {
        printf("Push: data[%d] = %s\n", i, *data[i]);
        pushBack(&buffer, (int*)data[i]);
    }
    printf("\n");
    for (int i = 0; i < size; i++)
    {
        printf("PushBack: queue[%d] = %s\n", i, (ringBuffer*)popFront(&buffer, (void*)data[i])); // !!!
    }
    printf("\n");

    for (int i = 0; i < size; i++)
    {
        printf("PopFront: data[%d] = %s\n", i, *data[i]);
        pushBack(&buffer, (int*)data[i]);
    }
    printf("\n");
    system("pause");
    return 0;
    }