ESP32 Forum

Code: Select all

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"

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

#include "driver/gpio.h"
#include "nvs_flash.h"
#include "esp_log.h"

#include "esp_netif.h"
#include "esp_eth.h"
#include "esp_eth_phy.h" //v6
#include "esp_event.h"

#include "./include/ethernet.h"
#include "./include/io.h"
#include "./include/nvs_read_write.h"
#include "./include/rtc.h"
#include "./include/mqtt.h"

#define TAG "ETHERNET"

//++ MODES
#define STATIC 0
#define DHCP 1

// Default Values
#define MODE DHCP

#define STATIC_IP "192.168.0.111" // v6
#define STATIC_GW "192.168.0.1"   // v6
#define STATIC_SN "255.255.255.0" // v6
#define STATIC_DNS1 "8.8.8.8"     // v6
#define STATIC_DNS2 "8.8.2.2"     // v6

extern bool mqtt_connected;

extern char mac_id[18]; //++ TO GET THE DEVICE MAC ID //v6
bool eth_con_flag = false;
// esp_netif_t *eth_netif;

static EventGroupHandle_t ethernet_events;
static const int CONNECTED_GOT_IP = BIT0;
static const int DISCONNECTED = BIT1;

char ethernet_dynamic_ip[20]; //++ to store ethernet ip when network is in dynamin mode

void eth_credential_read_nvs()
{
    memset(ethernet_dynamic_ip, 0, sizeof(ethernet_dynamic_ip));
    strcpy(ethernet_dynamic_ip, "-");
    eth_configure.nvs_eth_dhcp = read_nvs_u8("network_page", "dhcp", MODE);

    if (eth_configure.nvs_eth_dhcp == STATIC)
    {
        eth_configure.nvs_eth_ip = read_nvs_str("network_page", "static_ip", STATIC_IP);
        eth_configure.nvs_eth_gw = read_nvs_str("network_page", "static_gw", STATIC_GW);
        eth_configure.nvs_eth_snt = read_nvs_str("network_page", "static_snt", STATIC_SN);
        eth_configure.nvs_eth_dns1 = read_nvs_str("network_page", "static_dns1", STATIC_DNS1);
        eth_configure.nvs_eth_dns2 = read_nvs_str("network_page", "static_dns2", STATIC_DNS2);
    }
    vTaskDelay(50 / portTICK_PERIOD_MS);
}

static esp_err_t example_set_dns_server(esp_netif_t *netif, uint32_t addr, esp_netif_dns_type_t type)
{
    if (addr && (addr != IPADDR_NONE))
    {
        esp_netif_dns_info_t dns;
        dns.ip.u_addr.ip4.addr = addr;
        dns.ip.type = IPADDR_TYPE_V4;
        esp_netif_set_dns_info(netif, type, &dns);
    }
    return ESP_OK;
}

static void ethernet_set_static_ip(esp_netif_t *netif)
{
    if (esp_netif_dhcpc_stop(netif) != ESP_OK)
    {
        ESP_LOGE(TAG, "Failed to stop dhcp client");
        return;
    }
    esp_netif_ip_info_t ip;
    memset(&ip, 0, sizeof(esp_netif_ip_info_t));
    ip.ip.addr = ipaddr_addr(eth_configure.nvs_eth_ip);
    ip.netmask.addr = ipaddr_addr(eth_configure.nvs_eth_snt);
    ip.gw.addr = ipaddr_addr(eth_configure.nvs_eth_gw);
    if (esp_netif_set_ip_info(netif, &ip) != ESP_OK)
    {
        ESP_LOGE(TAG, "Failed to set ip info");
        return;
    }
    ESP_ERROR_CHECK(example_set_dns_server(netif, ipaddr_addr(eth_configure.nvs_eth_dns1), ESP_NETIF_DNS_MAIN));
    ESP_ERROR_CHECK(example_set_dns_server(netif, ipaddr_addr(eth_configure.nvs_eth_dns2), ESP_NETIF_DNS_BACKUP));
}

/** Event handler for Ethernet events */
void event_handler_for_ethernet(void *arg, esp_event_base_t event_base,
                                int32_t event_id, void *event_data)
{
    uint8_t mac_addr[6] = {0};
    /* we can get the ethernet driver handle from event data */
    esp_eth_handle_t eth_handle = *(esp_eth_handle_t *)event_data;

    switch (event_id)
    {
    case ETHERNET_EVENT_CONNECTED:
        esp_eth_ioctl(eth_handle, ETH_CMD_G_MAC_ADDR, mac_addr);
        ESP_LOGI(TAG, "Ethernet Link Up");
        ESP_LOGI(TAG, "Ethernet HW Addr %02x:%02x:%02x:%02x:%02x:%02x",
                 mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);

        if (eth_configure.nvs_eth_dhcp == STATIC)
            ethernet_set_static_ip(arg); // v6
        break;
    case ETHERNET_EVENT_DISCONNECTED:
        ESP_LOGE(TAG, "Ethernet Link Down");
        eth_con_flag = false;
        xEventGroupSetBits(ethernet_events, DISCONNECTED);

        if (mqtt_connected == true)
        {
            mqtt_app_stop();
            mqtt_connected = false;
        }
        break;
    case ETHERNET_EVENT_START:
        ESP_LOGI(TAG, "Ethernet Started");
        break;
    case ETHERNET_EVENT_STOP:
        ESP_LOGI(TAG, "Ethernet Stopped");
        break;
    case IP_EVENT_ETH_GOT_IP:
        eth_con_flag = true;
        eth_conn_count++;

        ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
        const esp_netif_ip_info_t *ip_info = &event->ip_info;

        // esp_netif_dns_info_t dns1, dns2;
        // esp_netif_get_dns_info(eth_netif, ESP_NETIF_DNS_MAIN, &dns1);
        // esp_netif_get_dns_info(eth_netif, ESP_NETIF_DNS_BACKUP, &dns2);

        ESP_LOGI(TAG, "\n\nxx -- ETHERNET CONNECTED -- xx\n");
        ESP_LOGI(TAG, "ethernet connection count: %d", eth_conn_count);
        ESP_LOGI(TAG, "IP :" IPSTR, IP2STR(&ip_info->ip));
        ESP_LOGI(TAG, "GATEWAY :" IPSTR, IP2STR(&ip_info->gw));
        ESP_LOGI(TAG, "SUBNET :" IPSTR, IP2STR(&ip_info->netmask));

        memset(ethernet_dynamic_ip, 0, sizeof(ethernet_dynamic_ip));
        memset(eth_gw, 0, sizeof(eth_gw));
        memset(eth_snt, 0, sizeof(eth_snt));
        memset(eth_dns, 0, sizeof(eth_dns));

        sprintf(ethernet_dynamic_ip, "" IPSTR, IP2STR(&ip_info->ip));
        sprintf(eth_gw, "" IPSTR, IP2STR(&ip_info->gw));
        sprintf(eth_snt, "" IPSTR, IP2STR(&ip_info->netmask));
        // sprintf(eth_dns, "" IPSTR, IP2STR(&dns1.ip.u_addr.ip4));

        eth_configure.nvs_eth_ip = ethernet_dynamic_ip;
        eth_configure.nvs_eth_gw = eth_gw;
        eth_configure.nvs_eth_snt = eth_snt;
        eth_configure.nvs_eth_dns1 = eth_dns;
        memset(eth_dns, 0, sizeof(eth_dns));
        // sprintf(eth_dns, "" IPSTR, IP2STR(&dns2.ip.u_addr.ip4));
        eth_configure.nvs_eth_dns2 = eth_dns;

        if (eth_configure.nvs_eth_dhcp == STATIC)
        {
            // ESP_LOGI(TAG, "DNS1 :" IPSTR, IP2STR(&dns1.ip.u_addr.ip4));
            // ESP_LOGI(TAG, "DNS2 :" IPSTR, IP2STR(&dns2.ip.u_addr.ip4));
            ESP_LOGI(TAG, "MODE : STATIC");
        }
        else
        {
            ESP_LOGI(TAG, "MODE : DHCP");
        }
        ESP_LOGI(TAG, "\n\nxx -- ETHERNET CONNECTED -- xx\n");

        vTaskDelay(50 / portTICK_PERIOD_MS);

        get_sntp_time();
        mqtt_app_start(mac_id);

        xEventGroupSetBits(ethernet_events, CONNECTED_GOT_IP);
        break;
    default:
        break;
    }
}

void ethernet_init(uint8_t mac_addr[])
{
    ESP_LOGI(TAG, "\n\nxx -- INITIALISING ETHERNET -- xx\n");

    eth_credential_read_nvs();

    ethernet_events = xEventGroupCreate();

    ESP_ERROR_CHECK(esp_netif_init());
    // Create default event loop that running in background
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_config_t netif_cfg = ESP_NETIF_DEFAULT_ETH();
    esp_netif_t *eth_netif = esp_netif_new(&netif_cfg);

    spi_bus_config_t buscfg = {
        .miso_io_num = ETH_SPI_MISO,
        .mosi_io_num = ETH_SPI_MOSI,
        .sclk_io_num = ETH_SPI_SCK,
        .quadwp_io_num = -1,
        .quadhd_io_num = -1,
    };
    ESP_ERROR_CHECK(spi_bus_initialize(ETH_SPI_HOST, &buscfg, SPI_DMA_CH_AUTO));
    /* ENC28J60 ethernet driver is based on spi driver */
    spi_device_interface_config_t devcfg = {
        .command_bits = 3,
        .address_bits = 5,
        .mode = 0,
        .clock_speed_hz = ETH_SPI_CLOCK_MHZ * 1000 * 1000,
        .spics_io_num = 5,
        .queue_size = 20,
        .cs_ena_posttrans = enc28j60_cal_spi_cs_hold_time(ETH_SPI_CLOCK_MHZ),
    };

    spi_device_handle_t spi_handle = NULL;
    ESP_ERROR_CHECK(spi_bus_add_device(ETH_SPI_HOST, &devcfg, &spi_handle));

    eth_enc28j60_config_t enc28j60_config = ETH_ENC28J60_DEFAULT_CONFIG(spi_handle);
    enc28j60_config.int_gpio_num = ETH_INT_GPIO;

    eth_mac_config_t mac_config = ETH_MAC_DEFAULT_CONFIG();
    mac_config.smi_mdc_gpio_num = -1; // ENC28J60 doesn't have SMI interface
    mac_config.smi_mdio_gpio_num = -1;
    esp_eth_mac_t *mac = esp_eth_mac_new_enc28j60(&enc28j60_config, &mac_config);

    eth_phy_config_t phy_config = ETH_PHY_DEFAULT_CONFIG();
    phy_config.autonego_timeout_ms = 0; // ENC28J60 doesn't support auto-negotiation
    phy_config.reset_gpio_num = -1;     // ENC28J60 doesn't have a pin to reset internal PHY
    esp_eth_phy_t *phy = esp_eth_phy_new_enc28j60(&phy_config);

    esp_eth_config_t eth_config = ETH_DEFAULT_CONFIG(mac, phy);
    esp_eth_handle_t eth_handle = NULL;
    ESP_ERROR_CHECK(esp_eth_driver_install(&eth_config, &eth_handle));

    /* ENC28J60 doesn't burn any factory MAC address, we need to set it manually.
       02:00:00 is a Locally Administered OUI range so should not be used except when testing on a LAN under your control.
    */
    mac->set_addr(mac, (uint8_t[]){
                           base_mac_addr[0], base_mac_addr[1], base_mac_addr[2], base_mac_addr[3], base_mac_addr[4], base_mac_addr[5]});

    // ENC28J60 Errata #1 check
    if (emac_enc28j60_get_chip_info(mac) < ENC28J60_REV_B5 && 8 < 8)
    {
        ESP_LOGE(TAG, "SPI frequency must be at least 8 MHz for chip revision less than 5");
        ESP_ERROR_CHECK(ESP_FAIL);
    }

    /* attach Ethernet driver to TCP/IP stack */
    ESP_ERROR_CHECK(esp_netif_attach(eth_netif, esp_eth_new_netif_glue(eth_handle)));
    // Register user defined event handers
    ESP_ERROR_CHECK(esp_event_handler_register(ETH_EVENT, ESP_EVENT_ANY_ID, &event_handler_for_ethernet, eth_netif));
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_ETH_GOT_IP, &event_handler_for_ethernet, eth_netif));
    /* start Ethernet driver state machine */
    ESP_ERROR_CHECK(esp_eth_start(eth_handle));

    /* Set duplex needs to be called after esp_eth_start since the driver is started with auto-negotiation by default */
    esp_err_t duplex_mode_status = enc28j60_set_phy_duplex(phy, ETH_DUPLEX_FULL);
    if (duplex_mode_status == ESP_OK)
    {
        ESP_LOGI(TAG, "[ ETHERNET TRANSMISSION MODE SET TO FULL DUPLEX ]");
    }

    xEventGroupWaitBits(ethernet_events, CONNECTED_GOT_IP | DISCONNECTED, pdTRUE, pdFALSE, pdMS_TO_TICKS(10000));

    esp_netif_dhcp_status_t status;
    esp_netif_dhcpc_get_status(eth_netif, &status);
    ESP_LOGW(TAG, " DHCPC  (state=%u)", status);
    if (status == 0x0)
    {
        // esp_err_t err_dhcp = esp_netif_dhcpc_start(eth_netif); // commented
        ESP_LOGI(TAG, "DHCP client status : %s", esp_err_to_name(status));
        ESP_LOGI(TAG, "[ Restarting ESP32 ]");
        esp_restart();
    }
}