ESP32: ETH + RELAY

[zital]

I see the relay 1 is 15 pin and relay 2 pin is 2 here:

https://www.kincony.com/forum/showthread.php?tid=2691

well, I flashed the ESP32 using idd.py and I build this code and works fine, but is using wifi, i need to work with ethernet, if someone can helps me I really appreciated:

PHP Code:

#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "esp_netif.h"
#include "esp_http_server.h"
#include "driver/gpio.h"

// Wi-Fi credentials
#define WIFI_SSID "WIFI_NAME"
#define WIFI_PASS "WIFI_PASSWORD"

// GPIOs for relays
#define RELAY1_GPIO GPIO_NUM_15
#define RELAY2_GPIO GPIO_NUM_2

static const char *TAG = "relay_server";

// Relay control
static void set_relay(int relay_num, bool on) {
    gpio_num_t gpio = (relay_num == 1) ? RELAY1_GPIO : RELAY2_GPIO;
    gpio_set_level(gpio, on ? 0 : 1);  // Active LOW
}

// HTTP Handlers
esp_err_t relay1_on_handler(httpd_req_t *req) {
    set_relay(1, false);
    httpd_resp_send(req, "Relay 1 ON", HTTPD_RESP_USE_STRLEN);
    return ESP_OK;
}

esp_err_t relay1_off_handler(httpd_req_t *req) {
    set_relay(1, true);
    httpd_resp_send(req, "Relay 1 OFF", HTTPD_RESP_USE_STRLEN);
    return ESP_OK;
}

esp_err_t relay2_on_handler(httpd_req_t *req) {
    set_relay(2, false);
    httpd_resp_send(req, "Relay 2 ON", HTTPD_RESP_USE_STRLEN);
    return ESP_OK;
}

esp_err_t relay2_off_handler(httpd_req_t *req) {
    set_relay(2, true);
    httpd_resp_send(req, "Relay 2 OFF", HTTPD_RESP_USE_STRLEN);
    return ESP_OK;
}

esp_err_t root_handler(httpd_req_t *req) {
    const char* resp_str =
        "ESP32 Relay Control:\n"
        "/relay1/on  or /relay1/off\n"
        "/relay2/on  or /relay2/off\n";
    httpd_resp_send(req, resp_str, HTTPD_RESP_USE_STRLEN);
    return ESP_OK;
}

// HTTP Server
httpd_handle_t start_webserver(void) {
    httpd_config_t config = HTTPD_DEFAULT_CONFIG();
    httpd_handle_t server = NULL;

    if (httpd_start(&server, &config) == ESP_OK) {
        httpd_uri_t root = {
            .uri       = "/",
            .method    = HTTP_GET,
            .handler   = root_handler,
            .user_ctx  = NULL
        };
        httpd_uri_t relay1_on = {
            .uri       = "/relay1/on",
            .method    = HTTP_GET,
            .handler   = relay1_on_handler,
            .user_ctx  = NULL
        };
        httpd_uri_t relay1_off = {
            .uri       = "/relay1/off",
            .method    = HTTP_GET,
            .handler   = relay1_off_handler,
            .user_ctx  = NULL
        };
        httpd_uri_t relay2_on = {
            .uri       = "/relay2/on",
            .method    = HTTP_GET,
            .handler   = relay2_on_handler,
            .user_ctx  = NULL
        };
        httpd_uri_t relay2_off = {
            .uri       = "/relay2/off",
            .method    = HTTP_GET,
            .handler   = relay2_off_handler,
            .user_ctx  = NULL
        };

        httpd_register_uri_handler(server, &root);
        httpd_register_uri_handler(server, &relay1_on);
        httpd_register_uri_handler(server, &relay1_off);
        httpd_register_uri_handler(server, &relay2_on);
        httpd_register_uri_handler(server, &relay2_off);
    }

    return server;
}

// Wi-Fi event handler
static void wifi_event_handler(void* arg, esp_event_base_t event_base,
                               int32_t event_id, void* event_data) {
    if (event_id == WIFI_EVENT_STA_START) {
        esp_wifi_connect();
    } else if (event_id == WIFI_EVENT_STA_DISCONNECTED) {
        esp_wifi_connect();
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        ESP_LOGI(TAG, "Connected with IP");
        start_webserver();
    }
}

// Initialize Wi-Fi
void wifi_init(void) {
    esp_netif_init();
    esp_event_loop_create_default();
    esp_netif_create_default_wifi_sta();

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    esp_wifi_init(&cfg);

    esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler, NULL);
    esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &wifi_event_handler, NULL);

    wifi_config_t wifi_config = {
        .sta = {
            .ssid = WIFI_SSID,
            .password = WIFI_PASS,
        },
    };
    esp_wifi_set_mode(WIFI_MODE_STA);
    esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config);
    esp_wifi_start();
}

// GPIO setup
void relay_gpio_init() {
    gpio_config_t io_conf = {
        .pin_bit_mask = (1ULL << RELAY1_GPIO) | (1ULL << RELAY2_GPIO),
        .mode = GPIO_MODE_OUTPUT,
        .pull_up_en = 0,
        .pull_down_en = 0,
        .intr_type = GPIO_INTR_DISABLE,
    };
    gpio_config(&io_conf);

    // Default state: OFF
    gpio_set_level(RELAY1_GPIO, 0);
    gpio_set_level(RELAY2_GPIO, 0);
}

void app_main(void) {
    ESP_ERROR_CHECK(nvs_flash_init());
    relay_gpio_init();
    wifi_init();
} 


To enable disable relays (you can see the IP in the logs):

http://IP/relay1/on
http://IP/relay1/off
http://IP/relay2/on
http://IP/relay2/off