diagram.json

mq-135

mq-135.chip.json

// Wokwi Custom Chip - For docs and examples see:
// https://docs.wokwi.com/chips-api/getting-started
//
// SPDX-License-Identifier: MIT
// Copyright 2023 Asep Oman Somantri

#include "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>

// Chip data.
typedef struct 
{
  pin_t VCC;
  pin_t OUT;
  pin_t GND;
  uint32_t adc01;
} chip_data_t;

// Returns true if the power source is connected correctly.
bool power_connected(void *data)
{
  chip_data_t *chip = (chip_data_t*)data;
  return pin_read(chip->VCC) && !pin_read(chip->GND);
}

// Timer function. Analog output based on voltage.
void chip_timer_callback(void *user_data) 
{
  if (power_connected(user_data))
  {
    chip_data_t *chip_data = (chip_data_t*)user_data;
    uint32_t adc01 = attr_read(chip_data->adc01);
    float volts = 0.0008056640625 * adc01;
    pin_dac_write(chip_data->OUT, volts);
  }
}

// Chip initialization.
void chip_init(void) 
{
  chip_data_t *chip_data = malloc(sizeof(chip_data_t));
  chip_data->VCC = pin_init("VCC", INPUT);
  chip_data->GND = pin_init("GND", INPUT);
  chip_data->OUT = pin_init("OUT", ANALOG);
  chip_data->adc01 = attr_init("adc01", 50);

  const timer_config_t config = 
  {
    .callback = chip_timer_callback,
    .user_data = chip_data,
  };

  timer_t timer_id = timer_init(&config);
  timer_start(timer_id, 10000, true);
}

mq-135.chip.c

mq-7

mq-7.chip.json

// Wokwi Custom Chip - For docs and examples see:
// https://docs.wokwi.com/chips-api/getting-started
//
// SPDX-License-Identifier: MIT
// Copyright 2023 Asep Oman Somantri

#include "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>

// Chip data.
typedef struct 
{
  pin_t VCC;
  pin_t OUT;
  pin_t GND;
  uint32_t adc02;
} chip_data_t;

// Returns true if the power source is connected correctly.
bool power_connected(void *data)
{
  chip_data_t *chip = (chip_data_t*)data;
  return pin_read(chip->VCC) && !pin_read(chip->GND);
}

// Timer function. Analog output based on voltage.
void chip_timer_callback(void *user_data) 
{
  if (power_connected(user_data))
  {
    chip_data_t *chip_data = (chip_data_t*)user_data;
    uint32_t adc02 = attr_read(chip_data->adc02);
    float volts = 0.0008056640625 * adc02;
    pin_dac_write(chip_data->OUT, volts);
  }
}

// Chip initialization.
void chip_init(void) 
{
  chip_data_t *chip_data = malloc(sizeof(chip_data_t));
  chip_data->VCC = pin_init("VCC", INPUT);
  chip_data->GND = pin_init("GND", INPUT);
  chip_data->OUT = pin_init("OUT", ANALOG);
  chip_data->adc02 = attr_init("adc02", 50);

  const timer_config_t config = 
  {
    .callback = chip_timer_callback,
    .user_data = chip_data,
  };

  timer_t timer_id = timer_init(&config);
  timer_start(timer_id, 10000, true);
}

mq-7.chip.c

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

# Automatically added based on includes:
LiquidCrystal I2C

WiFi


libraries.txt

#include <Arduino.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <ESPAsyncWebServer.h>
#include <WiFi.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);

const char* ssid = "android";
const char* password = "1234567890";

AsyncWebServer server(80);

int buz = 2;
int fan = 4;
int greenled = 5;
int redled = 18;

int gas_sensor = 34;
float m = -0.353;
float c = 0.711;
float R0 = 23.30;

int CO_sensor = 35;
float m1 = -0.67;
float c1 = 1.34;
float R01 = 5.80;

void setup() {
  Serial.begin(115200);
  lcd.init();
  lcd.backlight();
  lcd.print("Sistem Pemantauan");
  lcd.setCursor(0, 1);
  lcd.print("Polusi Udara");
  delay(4000);
  lcd.clear();
  
  pinMode(buz, OUTPUT);
  pinMode(greenled, OUTPUT);
  pinMode(redled, OUTPUT);
  pinMode(fan, OUTPUT);
  pinMode(gas_sensor, INPUT);
  pinMode(CO_sensor, INPUT);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }

  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    String html = "<!DOCTYPE html><html><head><title>Pemantauan Udara</title>";
    html += "<link rel='stylesheet' href='https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css'>";
    html += "<style>";
    html += "body { font-size: 16px; }";
    html += ".large-text { font-size: 48px; }";
    html += ".clean-air { border: 5px solid green; padding: 10px; }";
    html += ".dirty-air { border: 5px solid red; padding: 10px; }";
    html += "</style>";
    html += "</head><body><div class='container'>";
    html += "<h1 class='mt-3'>Pemantauan Kualitas Udara</h1>";
    html += "<div class='row'>";
    html += "<div class='col-md-6 mt-3'>";
    html += "<h2>CO2 PPM: <span id='co2Value' class='large-text'></span></h2>";
    html += "<h2>CO PPM: <span id='coValue' class='large-text'></span></h2>";
    html += "</div>";
    html += "<div class='col-md-6 mt-3'>";
    html += "<div id='airStatus' class='clean-air'>";
    html += "<h3>Status Udara: Bersih</h3>";
    html += "</div>";
    html += "</div>";
    html += "</div>";
    html += "<canvas id='chart' width='400' height='200'></canvas>";
    html += "<script src='https://cdn.jsdelivr.net/npm/chart.js'></script>";
    html += "<script>";
    html += "var ctx = document.getElementById('chart').getContext('2d');";
    html += "var chart = new Chart(ctx, {";
    html += "  type: 'line',";
    html += "  data: {";
    html += "    labels: [],";
    html += "    datasets: [{";
    html += "      label: 'CO2 PPM',";
    html += "      data: [],";
    html += "      borderColor: 'blue',";
    html += "      fill: false";
    html += "    }, {";
    html += "      label: 'CO PPM',";
    html += "      data: [],";
    html += "      borderColor: 'orange',";
    html += "      fill: false";
    html += "    }]";
    html += "  }";
    html += "});";
    html += "setInterval(function() {getData();}, 5000);";
    html += "function getData() {fetch('/data').then(response => response.json()).then(data => {";
    html += "  document.getElementById('co2Value').textContent = data.co2;";
    html += "  document.getElementById('coValue').textContent = data.co;";
    html += "  var airStatusElement = document.getElementById('airStatus');";
    html += "  airStatusElement.textContent = 'Status Udara: ' + data.status;";
    html += "  if (data.status === 'Udara Kotor') { airStatusElement.className = 'dirty-air'; }";
    html += "  else { airStatusElement.className = 'clean-air'; }";
    html += "  chart.data.labels.push(new Date().toLocaleTimeString());";
    html += "  chart.data.datasets[0].data.push(data.co2);";
    html += "  chart.data.datasets[1].data.push(data.co);";
    html += "  chart.update();";
    html += "});}";
    html += "</script>";
    html += "</div></body></html>";
    request->send(200, "text/html", html);
  });

  server.on("/data", HTTP_GET, [](AsyncWebServerRequest *request){
    float ppm = calculatePPM(analogRead(gas_sensor), R0, m, c);
    float ppm1 = calculatePPM(analogRead(CO_sensor), R01, m1, c1);
    String status = (ppm >= 10 || ppm1 >= 10) ? "Udara Kotor" : "Udara Normal";
    String json = "{\"co2\":" + String(ppm) + ",\"co\":" + String(ppm1) + ",\"status\":\"" + status + "\"}";
    request->send(200, "application/json", json);
  });

  server.begin();
}

void loop() {
  float ppm = calculatePPM(analogRead(gas_sensor), R0, m, c);
  float ppm1 = calculatePPM(analogRead(CO_sensor), R01, m1, c1);
  
  Serial.print("CO2 PPM: ");
  Serial.println(ppm);
  Serial.print("CO PPM: ");
  Serial.println(ppm1);

  if (ppm >= 10 || ppm1 >= 10) {
    digitalWrite(greenled, LOW);
    digitalWrite(buz, HIGH);
    digitalWrite(redled, HIGH);
    digitalWrite(fan, HIGH);
    lcd.setCursor(0, 1);
    lcd.print("Udara Kotor !!");
    Serial.println("Bahaya !!!");
    delay(2000);
    lcd.clear();
  } else {
    digitalWrite(greenled, HIGH);
    digitalWrite(redled, LOW);
    digitalWrite(buz, LOW);
    digitalWrite(fan, LOW);
    lcd.setCursor(0, 1);
    lcd.print("Udara Normal !!");
    Serial.println("Normal !!!");
    delay(2000);
    lcd.clear();
  }
  delay(1000);
}

float calculatePPM(int sensorValue, float R0, float m, float c) {
  float sensor_volt = sensorValue * (3.3 / 4096.0);
  float RS_gas = ((3.3 * 10.0) / sensor_volt) - 10.0;
  float ratio = RS_gas / R0;
  double ppm_log = (log10(ratio) - c) / m;
  double ppm = pow(10, ppm_log);
  return ppm;
}
        


sketch.ino

# Sistem Pemantauan Kualitas Udara

## Pendahuluan
Proyek ini adalah sistem pemantauan kualitas udara yang menggunakan perangkat ESP32 untuk mengukur tingkat CO2 dan CO dalam udara. Data yang diukur kemudian ditampilkan dalam bentuk grafik pada halaman web yang dapat diakses melalui jaringan WiFi.

## Komponen
- ESP32
- Modul LCD I2C (LiquidCrystal_I2C)
- Modul Sensor Gas (MQ-135) untuk CO2
- Modul Sensor Gas (MQ-7) untuk CO
- LED Hijau (indikator udara bersih)
- LED Merah (indikator udara kotor)
- Buzzer (untuk peringatan)
- Kipas (untuk sirkulasi udara)
- Breadboard dan kabel-kabel penghubung

## Koneksi Komponen
- Modul LCD dihubungkan melalui I2C (alamat 0x27)
- Pin sensor gas CO2 dihubungkan ke pin 34
- Pin sensor gas CO dihubungkan ke pin 35
- LED hijau dihubungkan ke pin 5
- LED merah dihubungkan ke pin 18
- Buzzer dihubungkan ke pin 2
- Kipas dihubungkan ke pin 4

## Algoritma
1. Pada saat setup, modul LCD akan menampilkan pesan "Sistem Pemantauan Polusi Udara" dan berubah setelah 4 detik.
2. Modul WiFi akan terhubung ke jaringan WiFi yang telah ditentukan.
3. Web server dijalankan pada port 80 dan memberikan akses ke halaman pemantauan.
4. Pada halaman web, digunakan Chart.js untuk menampilkan grafik tingkat CO2 dan CO dari waktu ke waktu.
5. Data dari sensor gas CO2 dan CO akan diambil setiap 5 detik dan ditampilkan pada halaman web.
6. Status kualitas udara (bersih atau kotor) akan dihitung berdasarkan ambang batas tertentu.
7. LED hijau atau merah akan menyala sesuai dengan status udara.
8. Buzzer akan berbunyi jika kualitas udara melewati ambang batas.

## Cara Menggunakan untuk Akses Web
1. Hubungkan komponen sesuai dengan koneksi yang telah dijelaskan.
2. Upload skrip ke perangkat Arduino atau ESP8266.
3. Pastikan perangkat terhubung ke jaringan WiFi yang sesuai.
4. Buka browser dan akses alamat IP perangkat di jaringan (biasanya ditampilkan di serial monitor setelah perangkat terhubung ke WiFi).
5. Anda akan melihat halaman pemantauan kualitas udara yang menampilkan grafik dan status udara.


# Penggunaan persamaan:

## Tahap 1: Hukum Ohm
Ini adalah persamaan dasar dari Hukum Ohm yang menghubungkan tegangan (V), arus (I), dan resistansi (R).

```
I = V/R
```

## Tahap 2: Tegangan Output pada Resistor Beban
Persamaan ini menghubungkan tegangan output (VRl) pada resistor beban (RL) dengan tegangan referensi (Vc), resistansi internal sensor (Rs), dan resistansi beban (Rl).

```
VRl = [Vc / (Rs + Rl)] * RL
```

## Tahap 3: Tegangan Output pada Resistor Beban dalam Bentuk Alternatif
Persamaan alternatif dari Persamaan 2, menggabungkan tegangan referensi (Vc), resistansi internal sensor (Rs), dan resistansi beban (Rl) dalam bentuk lain.

```
VRl = [Vc * Rl / (Rs + Rl)]
```

## Tahap 4: Perhitungan Resistansi Internal Sensor Rs
Persamaan ini membantu menghitung resistansi internal sensor (Rs) berdasarkan tegangan referensi (Vc), tegangan output pada resistor beban (VRl), dan resistansi beban (Rl).

```
Rs = (Vc * Rl) / (VRl - Rl)
```

## Tahap 5: Hubungan Antara Resistansi Internal Sensor Rs dan Ratio Rs/R0
Persamaan ini menghubungkan resistansi internal sensor (Rs) dengan rasio antara resistansi internal sensor dalam udara segar (R0) dan Rs.

```
Rs / R0 = 3.6
```

## Tahap 6: Pembuatan Persamaan untuk Menghitung Concentration Gas
Persamaan ini membantu menghitung konsentrasi gas berdasarkan nilai-nilai log-log dari rasio dan konsentrasi yang diperoleh dari grafik log-log. Ini melibatkan perhitungan miring (slope) m dan konstanta intercept b.

### Bagian 6.1: Menentukan Data dari Kurva Grafik
Ambil data dari kurva grafik pada datasheet sensor. Dapatkan setidaknya dua titik pada kurva yang mewakili perubahan resistansi dan konsentrasi gas. 

Tentukan nilai x0 dan y0 sebagai nilai x dan y pada salah satu titik yang Anda pilih.

Kunjungi situs : https://plotdigitizer.com. Panduan ekstrak data dari gambar grafik datasheet sensor di: https://plotdigitizer.com/extrac-data-graph-image

### Bagian 6.2: Hitung Nilai Miring (Slope) dan Konstanta Intercept (b)
Hitung nilai miring (slope) m menggunakan persamaan:

```
m = log(y / y0) / log(x / x0)
```

Hitung nilai konstanta intercept b menggunakan persamaan:

```
b = log(0.9) - (-0.318) * log(5000)
```

### Bagian 6.3: Menghitung Konsentrasi Gas
Setelah mendapatkan nilai m dan b, hitung nilai log(x) dengan persamaan:

```
log(x) = [log(y) - b] / m
```

Terakhir, hitung nilai konsentrasi gas x dengan persamaan:

```
x = 10^(log(y) - b) / m
```

Dalam praktiknya, Anda perlu memiliki nilai rasio y/y0 yang diukur dari sensor Anda. Setelah mendapatkan nilai ini, Anda bisa menggunakannya untuk menghitung nilai x, yang akan menjadi estimasi konsentrasi gas dalam satuan PPM.

readme.md

/*
  Asynchronous WebServer library for Espressif MCUs

  Copyright (c) 2016 Hristo Gochkov. All rights reserved.
  This file is part of the esp8266 core for Arduino environment.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/
#ifndef _ESPAsyncWebServer_H_
#define _ESPAsyncWebServer_H_

#include "Arduino.h"

#include <functional>
#include "FS.h"

#include "StringArray.h"

#ifdef ESP32
#include <WiFi.h>
#include <AsyncTCP.h>
#elif defined(ESP8266)
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#else
#error Platform not supported
#endif

#ifdef ASYNCWEBSERVER_REGEX
#define ASYNCWEBSERVER_REGEX_ATTRIBUTE
#else
#define ASYNCWEBSERVER_REGEX_ATTRIBUTE __attribute__((warning("ASYNCWEBSERVER_REGEX not defined")))
#endif

#define DEBUGF(...) //Serial.printf(__VA_ARGS__)

class AsyncWebServer;
class AsyncWebServerRequest;
class AsyncWebServerResponse;
class AsyncWebHeader;
class AsyncWebParameter;
class AsyncWebRewrite;
class AsyncWebHandler;
class AsyncStaticWebHandler;
class AsyncCallbackWebHandler;
class AsyncResponseStream;

#ifndef WEBSERVER_H
typedef enum {
  HTTP_GET     = 0b00000001,
  HTTP_POST    = 0b00000010,
  HTTP_DELETE  = 0b00000100,
  HTTP_PUT     = 0b00001000,
  HTTP_PATCH   = 0b00010000,
  HTTP_HEAD    = 0b00100000,
  HTTP_OPTIONS = 0b01000000,
  HTTP_ANY     = 0b01111111,
} WebRequestMethod;
#endif

//if this value is returned when asked for data, packet will not be sent and you will be asked for data again
#define RESPONSE_TRY_AGAIN 0xFFFFFFFF

typedef uint8_t WebRequestMethodComposite;
typedef std::function<void(void)> ArDisconnectHandler;

/*
 * PARAMETER :: Chainable object to hold GET/POST and FILE parameters
 * */

class AsyncWebParameter {
  private:
    String _name;
    String _value;
    size_t _size;
    bool _isForm;
    bool _isFile;

  public:

    AsyncWebParameter(const String& name, const String& value, bool form=false, bool file=false, size_t size=0): _name(name), _value(value), _size(size), _isForm(form), _isFile(file){}
    const String& name() const { return _name; }
    const String& value() const { return _value; }
    size_t size() const { return _size; }
    bool isPost() const { return _isForm; }
    bool isFile() const { return _isFile; }
};

/*
 * HEADER :: Chainable object to hold the headers
 * */

class AsyncWebHeader {
  private:
    String _name;
    String _value;

  public:
    AsyncWebHeader(const String& name, const String& value): _name(name), _value(value){}
    AsyncWebHeader(const String& data): _name(), _value(){
      if(!data) return;
      int index = data.indexOf(':');
      if (index < 0) return;
      _name = data.substring(0, index);
      _value = data.substring(index + 2);
    }
    ~AsyncWebHeader(){}
    const String& name() const { return _name; }
    const String& value() const { return _value; }
    String toString() const { return String(_name+": "+_value+"\r\n"); }
};

/*
 * REQUEST :: Each incoming Client is wrapped inside a Request and both live together until disconnect
 * */

typedef enum { RCT_NOT_USED = -1, RCT_DEFAULT = 0, RCT_HTTP, RCT_WS, RCT_EVENT, RCT_MAX } RequestedConnectionType;

typedef std::function<size_t(uint8_t*, size_t, size_t)> AwsResponseFiller;
typedef std::function<String(const String&)> AwsTemplateProcessor;

class AsyncWebServerRequest {
  using File = fs::File;
  using FS = fs::FS;
  friend class AsyncWebServer;
  friend class AsyncCallbackWebHandler;
  private:
    AsyncClient* _client;
    AsyncWebServer* _server;
    AsyncWebHandler* _handler;
    AsyncWebServerResponse* _response;
    StringArray _interestingHeaders;
    ArDisconnectHandler _onDisconnectfn;

    String _temp;
    uint8_t _parseState;

    uint8_t _version;
    WebRequestMethodComposite _method;
    String _url;
    String _host;
    String _contentType;
    String _boundary;
    String _authorization;
    RequestedConnectionType _reqconntype;
    void _removeNotInterestingHeaders();
    bool _isDigest;
    bool _isMultipart;
    bool _isPlainPost;
    bool _expectingContinue;
    size_t _contentLength;
    size_t _parsedLength;

    LinkedList<AsyncWebHeader *> _headers;
    LinkedList<AsyncWebParameter *> _params;
    LinkedList<String *> _pathParams;

    uint8_t _multiParseState;
    uint8_t _boundaryPosition;
    size_t _itemStartIndex;
    size_t _itemSize;
    String _itemName;
    String _itemFilename;
    String _itemType;
    String _itemValue;
    uint8_t *_itemBuffer;
    size_t _itemBufferIndex;
    bool _itemIsFile;

    void _onPoll();
    void _onAck(size_t len, uint32_t time);
    void _onError(int8_t error);
    void _onTimeout(uint32_t time);
    void _onDisconnect();
    void _onData(void *buf, size_t len);

    void _addParam(AsyncWebParameter*);
    void _addPathParam(const char *param);

    bool _parseReqHead();
    bool _parseReqHeader();
    void _parseLine();
    void _parsePlainPostChar(uint8_t data);
    void _parseMultipartPostByte(uint8_t data, bool last);
    void _addGetParams(const String& params);

    void _handleUploadStart();
    void _handleUploadByte(uint8_t data, bool last);
    void _handleUploadEnd();

  public:
    File _tempFile;
    void *_tempObject;

    AsyncWebServerRequest(AsyncWebServer*, AsyncClient*);
    ~AsyncWebServerRequest();

    AsyncClient* client(){ return _client; }
    uint8_t version() const { return _version; }
    WebRequestMethodComposite method() const { return _method; }
    const String& url() const { return _url; }
    const String& host() const { return _host; }
    const String& contentType() const { return _contentType; }
    size_t contentLength() const { return _contentLength; }
    bool multipart() const { return _isMultipart; }
    const char * methodToString() const;
    const char * requestedConnTypeToString() const;
    RequestedConnectionType requestedConnType() const { return _reqconntype; }
    bool isExpectedRequestedConnType(RequestedConnectionType erct1, RequestedConnectionType erct2 = RCT_NOT_USED, RequestedConnectionType erct3 = RCT_NOT_USED);
    void onDisconnect (ArDisconnectHandler fn);

    //hash is the string representation of:
    // base64(user:pass) for basic or
    // user:realm:md5(user:realm:pass) for digest
    bool authenticate(const char * hash);
    bool authenticate(const char * username, const char * password, const char * realm = NULL, bool passwordIsHash = false);
    void requestAuthentication(const char * realm = NULL, bool isDigest = true);

    void setHandler(AsyncWebHandler *handler){ _handler = handler; }
    void addInterestingHeader(const String& name);

    void redirect(const String& url);

    void send(AsyncWebServerResponse *response);
    void send(int code, const String& contentType=String(), const String& content=String());
    void send(FS &fs, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr);
    void send(File content, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr);
    void send(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback=nullptr);
    void send(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr);
    void sendChunked(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr);
    void send_P(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback=nullptr);
    void send_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback=nullptr);

    AsyncWebServerResponse *beginResponse(int code, const String& contentType=String(), const String& content=String());
    AsyncWebServerResponse *beginResponse(FS &fs, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr);
    AsyncWebServerResponse *beginResponse(File content, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr);
    AsyncWebServerResponse *beginResponse(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback=nullptr);
    AsyncWebServerResponse *beginResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr);
    AsyncWebServerResponse *beginChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr);
    AsyncResponseStream *beginResponseStream(const String& contentType, size_t bufferSize=1460);
    AsyncWebServerResponse *beginResponse_P(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback=nullptr);
    AsyncWebServerResponse *beginResponse_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback=nullptr);

    size_t headers() const;                     // get header count
    bool hasHeader(const String& name) const;   // check if header exists
    bool hasHeader(const __FlashStringHelper * data) const;   // check if header exists

    AsyncWebHeader* getHeader(const String& name) const;
    AsyncWebHeader* getHeader(const __FlashStringHelper * data) const;
    AsyncWebHeader* getHeader(size_t num) const;

    size_t params() const;                      // get arguments count
    bool hasParam(const String& name, bool post=false, bool file=false) const;
    bool hasParam(const __FlashStringHelper * data, bool post=false, bool file=false) const;

    AsyncWebParameter* getParam(const String& name, bool post=false, bool file=false) const;
    AsyncWebParameter* getParam(const __FlashStringHelper * data, bool post, bool file) const; 
    AsyncWebParameter* getParam(size_t num) const;

    size_t args() const { return params(); }     // get arguments count
    const String& arg(const String& name) const; // get request argument value by name
    const String& arg(const __FlashStringHelper * data) const; // get request argument value by F(name)    
    const String& arg(size_t i) const;           // get request argument value by number
    const String& argName(size_t i) const;       // get request argument name by number
    bool hasArg(const char* name) const;         // check if argument exists
    bool hasArg(const __FlashStringHelper * data) const;         // check if F(argument) exists

    const String& ASYNCWEBSERVER_REGEX_ATTRIBUTE pathArg(size_t i) const;

    const String& header(const char* name) const;// get request header value by name
    const String& header(const __FlashStringHelper * data) const;// get request header value by F(name)    
    const String& header(size_t i) const;        // get request header value by number
    const String& headerName(size_t i) const;    // get request header name by number
    String urlDecode(const String& text) const;
};

/*
 * FILTER :: Callback to filter AsyncWebRewrite and AsyncWebHandler (done by the Server)
 * */

typedef std::function<bool(AsyncWebServerRequest *request)> ArRequestFilterFunction;

bool ON_STA_FILTER(AsyncWebServerRequest *request);

bool ON_AP_FILTER(AsyncWebServerRequest *request);

/*
 * REWRITE :: One instance can be handle any Request (done by the Server)
 * */

class AsyncWebRewrite {
  protected:
    String _from;
    String _toUrl;
    String _params;
    ArRequestFilterFunction _filter;
  public:
    AsyncWebRewrite(const char* from, const char* to): _from(from), _toUrl(to), _params(String()), _filter(NULL){
      int index = _toUrl.indexOf('?');
      if (index > 0) {
        _params = _toUrl.substring(index +1);
        _toUrl = _toUrl.substring(0, index);
      }
    }
    virtual ~AsyncWebRewrite(){}
    AsyncWebRewrite& setFilter(ArRequestFilterFunction fn) { _filter = fn; return *this; }
    bool filter(AsyncWebServerRequest *request) const { return _filter == NULL || _filter(request); }
    const String& from(void) const { return _from; }
    const String& toUrl(void) const { return _toUrl; }
    const String& params(void) const { return _params; }
    virtual bool match(AsyncWebServerRequest *request) { return from() == request->url() && filter(request); }
};

/*
 * HANDLER :: One instance can be attached to any Request (done by the Server)
 * */

class AsyncWebHandler {
  protected:
    ArRequestFilterFunction _filter;
    String _username;
    String _password;
  public:
    AsyncWebHandler():_username(""), _password(""){}
    AsyncWebHandler& setFilter(ArRequestFilterFunction fn) { _filter = fn; return *this; }
    AsyncWebHandler& setAuthentication(const char *username, const char *password){  _username = String(username);_password = String(password); return *this; };
    bool filter(AsyncWebServerRequest *request){ return _filter == NULL || _filter(request); }
    virtual ~AsyncWebHandler(){}
    virtual bool canHandle(AsyncWebServerRequest *request __attribute__((unused))){
      return false;
    }
    virtual void handleRequest(AsyncWebServerRequest *request __attribute__((unused))){}
    virtual void handleUpload(AsyncWebServerRequest *request  __attribute__((unused)), const String& filename __attribute__((unused)), size_t index __attribute__((unused)), uint8_t *data __attribute__((unused)), size_t len __attribute__((unused)), bool final  __attribute__((unused))){}
    virtual void handleBody(AsyncWebServerRequest *request __attribute__((unused)), uint8_t *data __attribute__((unused)), size_t len __attribute__((unused)), size_t index __attribute__((unused)), size_t total __attribute__((unused))){}
    virtual bool isRequestHandlerTrivial(){return true;}
};

/*
 * RESPONSE :: One instance is created for each Request (attached by the Handler)
 * */

typedef enum {
  RESPONSE_SETUP, RESPONSE_HEADERS, RESPONSE_CONTENT, RESPONSE_WAIT_ACK, RESPONSE_END, RESPONSE_FAILED
} WebResponseState;

class AsyncWebServerResponse {
  protected:
    int _code;
    LinkedList<AsyncWebHeader *> _headers;
    String _contentType;
    size_t _contentLength;
    bool _sendContentLength;
    bool _chunked;
    size_t _headLength;
    size_t _sentLength;
    size_t _ackedLength;
    size_t _writtenLength;
    WebResponseState _state;
    const char* _responseCodeToString(int code);

  public:
    AsyncWebServerResponse();
    virtual ~AsyncWebServerResponse();
    virtual void setCode(int code);
    virtual void setContentLength(size_t len);
    virtual void setContentType(const String& type);
    virtual void addHeader(const String& name, const String& value);
    virtual String _assembleHead(uint8_t version);
    virtual bool _started() const;
    virtual bool _finished() const;
    virtual bool _failed() const;
    virtual bool _sourceValid() const;
    virtual void _respond(AsyncWebServerRequest *request);
    virtual size_t _ack(AsyncWebServerRequest *request, size_t len, uint32_t time);
};

/*
 * SERVER :: One instance
 * */

typedef std::function<void(AsyncWebServerRequest *request)> ArRequestHandlerFunction;
typedef std::function<void(AsyncWebServerRequest *request, const String& filename, size_t index, uint8_t *data, size_t len, bool final)> ArUploadHandlerFunction;
typedef std::function<void(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total)> ArBodyHandlerFunction;

class AsyncWebServer {
  protected:
    AsyncServer _server;
    LinkedList<AsyncWebRewrite*> _rewrites;
    LinkedList<AsyncWebHandler*> _handlers;
    AsyncCallbackWebHandler* _catchAllHandler;

  public:
    AsyncWebServer(uint16_t port);
    ~AsyncWebServer();

    void begin();
    void end();

#if ASYNC_TCP_SSL_ENABLED
    void onSslFileRequest(AcSSlFileHandler cb, void* arg);
    void beginSecure(const char *cert, const char *private_key_file, const char *password);
#endif

    AsyncWebRewrite& addRewrite(AsyncWebRewrite* rewrite);
    bool removeRewrite(AsyncWebRewrite* rewrite);
    AsyncWebRewrite& rewrite(const char* from, const char* to);

    AsyncWebHandler& addHandler(AsyncWebHandler* handler);
    bool removeHandler(AsyncWebHandler* handler);
  
    AsyncCallbackWebHandler& on(const char* uri, ArRequestHandlerFunction onRequest);
    AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest);
    AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload);
    AsyncCallbackWebHandler& on(const char* uri, WebRequestMethodComposite method, ArRequestHandlerFunction onRequest, ArUploadHandlerFunction onUpload, ArBodyHandlerFunction onBody);

    AsyncStaticWebHandler& serveStatic(const char* uri, fs::FS& fs, const char* path, const char* cache_control = NULL);

    void onNotFound(ArRequestHandlerFunction fn);  //called when handler is not assigned
    void onFileUpload(ArUploadHandlerFunction fn); //handle file uploads
    void onRequestBody(ArBodyHandlerFunction fn); //handle posts with plain body content (JSON often transmitted this way as a request)

    void reset(); //remove all writers and handlers, with onNotFound/onFileUpload/onRequestBody 
  
    void _handleDisconnect(AsyncWebServerRequest *request);
    void _attachHandler(AsyncWebServerRequest *request);
    void _rewriteRequest(AsyncWebServerRequest *request);
};

class DefaultHeaders {
  using headers_t = LinkedList<AsyncWebHeader *>;
  headers_t _headers;
  
  DefaultHeaders()
  :_headers(headers_t([](AsyncWebHeader *h){ delete h; }))
  {}
public:
  using ConstIterator = headers_t::ConstIterator;

  void addHeader(const String& name, const String& value){
    _headers.add(new AsyncWebHeader(name, value));
  }  
  
  ConstIterator begin() const { return _headers.begin(); }
  ConstIterator end() const { return _headers.end(); }

  DefaultHeaders(DefaultHeaders const &) = delete;
  DefaultHeaders &operator=(DefaultHeaders const &) = delete;
  static DefaultHeaders &Instance() {
    static DefaultHeaders instance;
    return instance;
  }
};

#include "WebResponseImpl.h"
#include "WebHandlerImpl.h"
#include "AsyncWebSocket.h"
#include "AsyncEventSource.h"

#endif /* _AsyncWebServer_H_ */
