#include 
#include 

#define LED_PIN 48

const char* ssid = "ESP32_S3_AP";
const char* password = "12345678";

WebServer server(80);

void handleOn() {
    digitalWrite(LED_PIN, HIGH);
    server.send(200, "text/plain", "LED ON");
}

void handleOff() {
    digitalWrite(LED_PIN, LOW);
    server.send(200, "text/plain", "LED OFF");
}

void handleRoot() {
    String html = "
ESP32 LED Control
"
                 "Turn ON
"
                 "Turn OFF";
    server.send(200, "text/html", html);
}

void setup() {
    Serial.begin(115200);
    pinMode(LED_PIN, OUTPUT);

    WiFi.softAP(ssid, password);
    Serial.print("Access Point started. IP: ");
    Serial.println(WiFi.softAPIP());

    server.on("/", handleRoot);
    server.on("/on", handleOn);
    server.on("/off", handleOff);
    server.begin();
}

void loop() {
    server.handleClient();
}

#include 
#include 

const char* ssid = "ESP32_S3_AP";
const char* password = "12345678";

#define BUTTON_PIN 1 // Push button input (active LOW)
bool lastButtonState = HIGH;
const char* serverIP = "192.168.4.1";

void setup() {
    Serial.begin(115200);
    pinMode(BUTTON_PIN, INPUT_PULLUP);

    WiFi.begin(ssid, password);
    Serial.print("Connecting to ");
    Serial.println(ssid);

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

    Serial.println("\nConnected to AP. IP address: ");
    Serial.println(WiFi.localIP());
}

void loop() {
    bool buttonState = digitalRead(BUTTON_PIN);

    if (buttonState == LOW && lastButtonState == HIGH) {
        sendLEDCommand(true);
        delay(500); // Simple debounce
    } else if (buttonState == HIGH && lastButtonState == LOW) {
        sendLEDCommand(false);
        delay(500);
    }

    lastButtonState = buttonState;
}

void sendLEDCommand(bool turnOn) {
    if (WiFi.status() == WL_CONNECTED) {
        HTTPClient http;
        String url = String("http://") + serverIP + (turnOn ? "/on" : "/off");
        http.begin(url);
        int httpCode = http.GET();

        if (httpCode > 0) {
            Serial.printf("Sent %s, Response: %d\n", turnOn ? "ON" : "OFF", httpCode);
        } else {
            Serial.printf("Failed to send request: %s\n", http.errorToString(httpCode).c_str());
        }
        http.end();
    } else {
        Serial.println("WiFi not connected");
    }
}

#include 
#include 
#include 
#include 

// UUIDs must match the web interface
#define SERVICE_UUID        "19b10000-e8f2-537e-4f6c-d104768a1214"
#define CHARACTERISTIC_UUID "19b10002-e8f2-537e-4f6c-d104768a1214"

const int ledPin = 21; // Built-in LED or change to your GPIO pin
const int pwmChannel = 0;
const int pwmFreq = 5000;
const int pwmResolution = 8;

bool isBlinking = false;
unsigned long lastBlinkTime = 0;
int blinkInterval = 500;
bool ledState = false;

class LEDCommandCallback : public BLECharacteristicCallbacks {
  void onWrite(BLECharacteristic* characteristic) override {
    std::string value = characteristic->getValue();
    if (value.length() > 0) {
      uint8_t command = value[0];

      if (command == 0) {
        isBlinking = false;
        ledcWrite(pwmChannel, 0);
        Serial.println("LED OFF");
      }
      else if (command == 1) {
        isBlinking = false;
        ledcWrite(pwmChannel, 255);
        Serial.println("LED ON");
      }
      else if (command == 2) {
        isBlinking = true;
        Serial.println("LED BLINKING");
      }
      else if (command >= 3 && command <= 255) {
        isBlinking = false;
        ledcWrite(pwmChannel, command);
        Serial.printf("LED Brightness: %d\n", command);
      }
    }
  }
};

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

  // PWM LED setup
  ledcSetup(pwmChannel, pwmFreq, pwmResolution);
  ledcAttachPin(ledPin, pwmChannel);
  ledcWrite(pwmChannel, 0);

  // BLE Setup
  BLEDevice::init("ESP32 LED Lamp");
  BLEServer* server = BLEDevice::createServer();
  BLEService* service = server->createService(SERVICE_UUID);
  BLECharacteristic* characteristic = service->createCharacteristic(
    CHARACTERISTIC_UUID,
    BLECharacteristic::PROPERTY_WRITE
  );

  characteristic->setCallbacks(new LEDCommandCallback());
  characteristic->addDescriptor(new BLE2902());

  service->start();
  server->getAdvertising()->start();

  Serial.println("BLE LED Controller is ready!");
}

void loop() {
  if (isBlinking) {
    unsigned long currentTime = millis();
    if (currentTime - lastBlinkTime > blinkInterval) {
      ledState = !ledState;
      ledcWrite(pwmChannel, ledState ? 255 : 0);
      lastBlinkTime = currentTime;
    }
  }
}