mn_basic_netif.hpp

Go to the documentation of this file.

#ifndef _MINTHREAH_BASIC_NETIF_HPP_
#define _MINTHREAH_BASIC_NETIF_HPP_
 
#include "mn_config.hpp"
 
 
#include <esp_interface.h>
#include <esp_netif.h>
#include <esp_wifi.h>
 
#if CONFIG_ETH_USE_SPI_ETHERNET
#include <driver/spi_master.h>
#endif // CONFIG_ETH_USE_SPI_ETHERNET
 
#include <net/mn_basic_ip_address.hpp>
#include <net/mn_basic_ip4_address.hpp>
#include <net/mn_basic_ip6_address.hpp>
 
#include "mn_lock.hpp"
 
namespace mn {
    namespace device {
 
        class basic_net_if {
            public:
                using ip4_address_t = net::basic_ip4_address;
 
                struct ip_info {
                    ip4_address_t ip;      
                    ip4_address_t netmask; 
                    ip4_address_t gw;      
                };
                using ip_info_t = ip_info;
 
                basic_net_if();
                basic_net_if(const basic_net_if& other)
                    :  m_ifConfig(other.m_ifConfig), m_pNetIf(other.m_pNetIf) { }
                basic_net_if& operator = (const basic_net_if& other);
 
                virtual bool    create_default() = 0;
 
                static bool start();
 
                static bool stop();
                int             set_mac(uint8_t mac[6]);
 
                esp_err_t       get_mac(uint8_t mac[6]);
 
                const char*     get_hostname();
 
                bool            set_hostname(const char* hostname);
 
                bool            is_up();
 
                int                     get_impl_name(char name[6]);
                int                     get_impl_index();
 
                virtual esp_netif_t*        get_netif() { return m_pNetIf; }
 
                virtual esp_netif_config_t* get_config() { return m_ifConfig; }
 
                int                         get_ip_infos(ip_info_t& ip_info);
 
                int                         set_ip_infos(const ip_info_t& ip_info);
 
                operator bool()          { return is_up(); }
                operator esp_netif_t* () { return m_pNetIf;}
 
                bool operator == (const basic_net_if& other);
                bool operator != (const basic_net_if& other);
 
                bool operator == (const esp_netif_t* other);
                bool operator != (const esp_netif_t* other);
            protected:
                esp_netif_config_t* m_ifConfig;
                esp_netif_t*        m_pNetIf;
        };
    }
}
 
#endif // _MINTHREAH_BASIC_NETIF_HPP_