RF24Ethernet.cpp

Go to the documentation of this file.

/*
 RF24Ethernet.cpp - Arduino implementation of a uIP wrapper class.
 Copyright (c) 2014 tmrh20@gmail.com, github.com/TMRh20
 Copyright (c) 2013 Norbert Truchsess <norbert.truchsess@t-online.de>
 All rights reserved.
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 This program 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 General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
#include "RF24Ethernet.h"
 
#if USE_LWIP == 2
 
    #include <zephyr/kernel.h>
    #include <zephyr/logging/log.h>
    #include <zephyr/net/net_pkt.h>
    #include <zephyr/net/net_if.h>
    #include <zephyr/net/net_core.h>
    #include <zephyr/net/ethernet.h>
    #include <zephyr/net/net_ip.h>
 
IPAddress RF24EthernetClass::_dnsServerAddress;
 
extern "C" {
    #include "drivers/net/rf24_netif.h"
}
 
extern "C" int rf24_cpp_tx_frame(const uint8_t* data, size_t len)
{
    return RF24Ethernet.sendFrame(data, len); // global instance
}
 
#endif
 
#if USE_LWIP == 1
RF24EthernetClass::EthQueue RF24EthernetClass::RXQueue;
RF24EthernetClass::EthTxQueue RF24EthernetClass::TXQueue;
netif RF24EthernetClass::myNetif;
bool RF24EthernetClass::useCoreLocking;
uint8_t RF24EthernetClass::networkBuffer[MAX_PAYLOAD_SIZE];
IPAddress RF24EthernetClass::_dnsServerAddress;
 
/*************************************************************/
 
void RF24EthernetClass::initRXQueue(EthQueue* RXQueue)
{
    RXQueue->nWrite = 0;
    RXQueue->nRead = 0;
}
 
/*************************************************************/
 
//Saves RX ethernet frame to the buffer to be processed in the main loop
void RF24EthernetClass::writeRXQueue(EthQueue* RXQueue, const uint8_t* ethFrame, uint16_t lenEthFrame)
{
    if (lenEthFrame > MAX_FRAME_SIZE)
    {
        lenEthFrame = MAX_FRAME_SIZE;
    }
 
    const uint32_t next = (RXQueue->nWrite + 1) % MAX_RX_QUEUE;
    if (next == RXQueue->nRead)
    {
        return; // Queue is full, keep the unread frame and drop this one
    }
 
    memcpy(&RXQueue->data[RXQueue->nWrite], ethFrame, lenEthFrame);
    RXQueue->len[RXQueue->nWrite] = lenEthFrame;
    RXQueue->nWrite = next;
}
 
/*************************************************************/
 
pbuf* RF24EthernetClass::readRXQueue(EthQueue* RXQueue)
{
    if (RXQueue->nWrite == RXQueue->nRead)
        return nullptr;
 
    uint16_t frameLen = RXQueue->len[RXQueue->nRead];
 
    if (frameLen > MAX_FRAME_SIZE) {
        RXQueue->nRead = (RXQueue->nRead + 1) % MAX_RX_QUEUE;
        return nullptr;
    }
 
    pbuf* p = pbuf_alloc(PBUF_IP, frameLen, PBUF_RAM);
 
    if (p) {
        if (pbuf_take(p, &RXQueue->data[RXQueue->nRead], frameLen) == ERR_OK) {
            RXQueue->nRead = (RXQueue->nRead + 1) % MAX_RX_QUEUE;
            return p;
        }
        pbuf_free(p);
    }
 
    return nullptr;
}
 
/*************************************************************/
 
bool RF24EthernetClass::isUnicast(const uint8_t frame)
{
    return (frame & 0x01) == 0;
}
 
/*************************************************************/
 
static void sendFrameToRadio(const char* buf, uint16_t total_len)
{
    if (Ethernet.isUnicast(buf[0]))
    {
        MIB2_STATS_NETIF_INC(&Ethernet.myNetif, ifoutucastpkts);
    }
    else
    {
        MIB2_STATS_NETIF_INC(&Ethernet.myNetif, ifoutnucastpkts);
    }
 
    IPAddress gwIP = Ethernet.gatewayIP();
    int16_t nodeAddress = 0;
 
    //If not the master node
    if (Ethernet.mesh.mesh_address != 0) {
        if (gwIP[3] != buf[19]) { // If not sending to the gateway
            IPAddress local_ip = Ethernet.localIP();
            if (local_ip[0] == buf[16] && local_ip[1] == buf[17]) { // If we are local within the nRF24 network
                //Request an address lookup from the Master node
                nodeAddress = Ethernet.mesh.getAddress((char)buf[19]); // Do an address lookup
                if (nodeAddress < 0) {
                    nodeAddress = 0; // If the result is negative, send to master
                }
            } // If this address is outside the nRF24 network, it will be send to master (00)
        }
    }
    else {
        IPAddress local_ip = Ethernet.localIP();
        if (local_ip[0] == buf[16] && local_ip[1] == buf[17]) { // If within the nRF24 radio network, do a lookup, else send to self (00)
            nodeAddress = Ethernet.mesh.getAddress((char)buf[19]);
            if (nodeAddress < 0) {
                return;
            }
        }
    }
 
    IF_ETH_DEBUG_L1(Serial.print("Net: Out "); Serial.println(nodeAddress, OCT););
 
    RF24NetworkHeader headerOut(nodeAddress, EXTERNAL_DATA_TYPE);
 
    if (total_len && total_len <= MAX_PAYLOAD_SIZE) {
        RF24Ethernet.network.write(headerOut, buf, total_len);
    }
}
 
/*************************************************************/
 
err_t netif_output(struct netif* netif, struct pbuf* p)
{
    void* context = netif->state;
    uint16_t total_len = p->tot_len;
 
    if (p->tot_len > Ethernet.MAX_FRAME_SIZE)
    {
        MIB2_STATS_NETIF_INC(netif, ifoutdiscards);
        return ERR_IF;
    }
    if (p->tot_len < Ethernet.MIN_FRAME_SIZE) // Pad to minimum ETH size
    {
        total_len = Ethernet.MIN_FRAME_SIZE;
    }
 
    RF24EthernetClass::EthTxQueue& queue = RF24EthernetClass::TXQueue;
 
    // TCP keeps the segment and tries again later when it gets ERR_MEM
    if (queue.nWrite - queue.nRead >= RF24EthernetClass::MAX_TX_QUEUE)
    {
        MIB2_STATS_NETIF_INC(netif, ifoutdiscards);
        return ERR_MEM;
    }
 
    const uint32_t slot = queue.nWrite % RF24EthernetClass::MAX_TX_QUEUE;
    pbuf_copy_partial(p, queue.data[slot], p->tot_len, 0);
    memset(&queue.data[slot][p->tot_len], 0, total_len - p->tot_len);
    queue.len[slot] = total_len;
    ETHERNET_TX_BARRIER();
    queue.nWrite = queue.nWrite + 1;
 
    LINK_STATS_INC(link.xmit);
    MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p->tot_len);
 
    return ERR_OK;
}
 
/*************************************************************/
 
void RF24EthernetClass::sendQueuedFrame()
{
    if (TXQueue.nRead == TXQueue.nWrite)
    {
        return;
    }
    ETHERNET_TX_BARRIER(); // See the complete frame that nWrite published
 
    const uint32_t slot = TXQueue.nRead % MAX_TX_QUEUE;
    sendFrameToRadio(reinterpret_cast<const char*>(TXQueue.data[slot]), TXQueue.len[slot]);
    ETHERNET_TX_BARRIER();
    TXQueue.nRead = TXQueue.nRead + 1;
}
 
/*************************************************************/
 
err_t tun_netif_output(struct netif* netif, struct pbuf* p, const ip4_addr_t* ipaddr)
{
    /* Since this is a TUN/L3 interface, we skip ARP (etharp_output).
       We simply call the linkoutput function to send the raw IP packet. */
    return netif->linkoutput(netif, p);
}
 
/*************************************************************/
 
err_t netif_init(struct netif* myNetif)
{
 
    myNetif->name[0] = 'e';
    myNetif->name[1] = '0';
    myNetif->linkoutput = netif_output;
    myNetif->output = tun_netif_output;
    myNetif->mtu = MAX_PAYLOAD_SIZE; //ETHERNET_MTU;
    myNetif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_IGMP | NETIF_FLAG_MLD6 | NETIF_FLAG_LINK_UP;
    myNetif->hostname = "TmrNet";
    MIB2_INIT_NETIF(&Ethernet.myNetif, snmp_ifType_ppp, Ethernet.NetIF_Speed_BPS);
    //SMEMCPY(myNetif->hwaddr, &Ethernet.MacAddr, sizeof(myNetif->hwaddr));
    myNetif->hwaddr_len = 0; //sizeof(netif->hwaddr);
    Ethernet.initRXQueue(&Ethernet.RXQueue);
    Ethernet.TXQueue.nRead = 0;
    Ethernet.TXQueue.nWrite = 0;
    netif_set_link_up(myNetif);
    return ERR_OK;
}
 
#endif
 
/*************************************************************/
#if !defined NRF52_RADIO_LIBRARY
    #if defined(RF24_TAP)
RF24EthernetClass::RF24EthernetClass(RF24& _radio, RF24Network& _network) : radio(_radio), network(_network) // fn_uip_cb(NULL)
{
        #if USE_LWIP == 1
    RF24Client::gState[0] = new RF24Client::ConnectState;
    RF24Client::gState[1] = new RF24Client::ConnectState;
        #endif
        #if USE_LWIP == 2
    isInitialized = false;
        #endif
}
 
    #else // Using RF24Mesh
RF24EthernetClass::RF24EthernetClass(RF24& _radio, RF24Network& _network, RF24Mesh& _mesh) : radio(_radio), network(_network), mesh(_mesh) // fn_uip_cb(NULL)
{
        #if USE_LWIP == 1
    RF24Client::gState[0] = new RF24Client::ConnectState;
    RF24Client::gState[1] = new RF24Client::ConnectState;
        #endif
        #if USE_LWIP == 2
    isInitialized = false;
        #endif
}
    #endif
 
#else
    #if defined(RF24_TAP)
RF24EthernetClass::RF24EthernetClass(nrf_to_nrf& _radio, RF52Network& _network) : radio(_radio), network(_network) // fn_uip_cb(NULL)
{
        #if USE_LWIP == 1
    RF24Client::gState[0] = new RF24Client::ConnectState;
    RF24Client::gState[1] = new RF24Client::ConnectState;
        #endif
        #if USE_LWIP == 2
    isInitialized = false;
        #endif
}
 
    #else // Using RF24Mesh
RF24EthernetClass::RF24EthernetClass(nrf_to_nrf& _radio, RF52Network& _network, RF52Mesh& _mesh) : radio(_radio), network(_network), mesh(_mesh) // fn_uip_cb(NULL)
{
        #if USE_LWIP == 1
    RF24Client::gState[0] = new RF24Client::ConnectState;
    RF24Client::gState[1] = new RF24Client::ConnectState;
        #endif
        #if USE_LWIP == 2
    isInitialized = false;
        #endif
}
    #endif
#endif
/*************************************************************/
 
void RF24EthernetClass::update()
{
    Ethernet.tick();
}
 
/*************************************************************/
 
void RF24EthernetClass::use_device()
{
    // Kept for backwards compatibility only
}
 
/*******************************************************/
 
void RF24EthernetClass::setMac(uint16_t address)
{
    if (!network.multicastRelay) { // Radio has not been started yet
        radio.begin();
    }
 
    const uint8_t mac[6] = {0x52, 0x46, 0x32, 0x34, (uint8_t)address, (uint8_t)(address >> 8)};
    // printf("MAC: %o %d\n", address, mac[0]);
 
#if defined(RF24_TAP)
    uip_seteth_addr(mac);
    network.multicastRelay = 1;
#else
    if (mac[0] == 1) {
        // Dummy operation to prevent warnings if TAP not defined
    };
#endif
    RF24_Channel = RF24_Channel ? RF24_Channel : 97;
    network.begin(RF24_Channel, address);
}
 
/*******************************************************/
 
void RF24EthernetClass::setChannel(uint8_t channel)
{
    RF24_Channel = channel;
    if (network.multicastRelay) { // Radio has not been started yet
        radio.setChannel(RF24_Channel);
    }
}
 
/*******************************************************/
 
void RF24EthernetClass::begin(IPAddress ip)
{
    IPAddress dns = {8, 8, 8, 8};
    begin(ip, dns);
}
 
/*******************************************************/
 
void RF24EthernetClass::begin(IPAddress ip, IPAddress dns)
{
    IPAddress gateway = ip;
    gateway[3] = 1;
    begin(ip, dns, gateway);
}
 
/*******************************************************/
 
void RF24EthernetClass::begin(IPAddress ip, IPAddress dns, IPAddress gateway)
{
    IPAddress subnet(255, 255, 255, 0);
    begin(ip, dns, gateway, subnet);
}
 
/*******************************************************/
 
void RF24EthernetClass::begin(IPAddress ip, IPAddress dns, IPAddress gateway, IPAddress subnet)
{
    configure(ip, dns, gateway, subnet);
}
 
/*******************************************************/
 
void RF24EthernetClass::configure(IPAddress ip, IPAddress dns, IPAddress gateway, IPAddress subnet)
{
#if !defined(RF24_TAP) // Using RF24Mesh
    mesh.setNodeID(ip[3]);
#endif
 
#if USE_LWIP < 1
    uip_buf = (uint8_t*)&network.frag_ptr->message_buffer[0];
 
    uip_ipaddr_t ipaddr;
    uip_ip_addr(ipaddr, ip);
    uip_sethostaddr(ipaddr);
    uip_ip_addr(ipaddr, gateway);
    uip_setdraddr(ipaddr);
    uip_ip_addr(ipaddr, subnet);
    uip_setnetmask(ipaddr);
    _dnsServerAddress = dns;
 
    timer_set(&this->periodic_timer, CLOCK_SECOND / UIP_TIMER_DIVISOR);
 
    #if defined(RF24_TAP)
    timer_set(&this->arp_timer, CLOCK_SECOND * 2);
    #endif
 
    uip_init();
    #if defined(RF24_TAP)
    uip_arp_init();
    #endif
#elif USE_LWIP == 1
 
    RF24Client::activeState = 0;
    // Allocate data for a single client
    RF24Client::incomingData[RF24Client::activeState] = (char*)malloc(INCOMING_DATA_SIZE);
    RF24Client::clientConnectionTimeout = 0;
    RF24Client::serverConnectionTimeout = 30000;
 
    #if defined RF24ETHERNET_CORE_REQUIRES_LOCKING && defined ESP32
    wifi_mode_t mode;
    esp_err_t err = esp_wifi_get_mode(&mode);
    if (err == ESP_OK) {
        useCoreLocking = true;
    }
    else {
        useCoreLocking = false;
    }
    #elif defined RF24ETHERNET_CORE_REQUIRES_LOCKING
    useCoreLocking = true;
    #endif
 
    ip4_addr_t myIp, myMask, myGateway;
    IP4_ADDR(&myIp, ip[0], ip[1], ip[2], ip[3]);
    IP4_ADDR(&myMask, subnet[0], subnet[1], subnet[2], subnet[3]);
    IP4_ADDR(&myGateway, gateway[0], gateway[1], gateway[2], gateway[3]);
    _dnsServerAddress = dns;
 
    void* context = nullptr;
    #if defined RF24ETHERNET_CORE_REQUIRES_LOCKING
    if (useCoreLocking) {
        ETHERNET_APPLY_LOCK();
    }
    #endif
    netif_add(&Ethernet.myNetif, &myIp, &myMask, &myGateway, context, netif_init, ip_input);
    netif_set_default(&Ethernet.myNetif);
    netif_set_up(&Ethernet.myNetif);
    #if defined RF24ETHERNET_CORE_REQUIRES_LOCKING
    if (useCoreLocking) {
        ETHERNET_REMOVE_LOCK();
    }
    #endif
 
#elif USE_LWIP == 2
 
    struct net_if* iface = rf24_netif_get_iface();
    if (!iface) {
        IF_RF24ETHERNET_DEBUG_CLIENT(printk("NET: rf24 iface null\n"));
        return;
    }
 
    struct in_addr my_ip, netmask, gw;
 
    my_ip.s_addr = (uint32_t)ip;
    netmask.s_addr = (uint32_t)subnet;
    gw.s_addr = (uint32_t)gateway;
 
    //net_addr_pton(AF_INET, (uint32_t)ip, &my_ip);
    //net_addr_pton(AF_INET, (uint32_t)subnet, &netmask);
    //net_addr_pton(AF_INET, (uint32_t)gateway, &gw);
 
    net_if_ipv4_addr_add(iface, &my_ip, NET_ADDR_MANUAL, 0);
    net_if_ipv4_set_netmask_by_addr(iface, &my_ip, &netmask);
    net_if_ipv4_set_gw(iface, &gw);
 
    int ret = net_if_up(iface);
    if (ret < 0 && ret != -EALREADY) {
        IF_RF24ETHERNET_DEBUG_CLIENT(printk("NET: net_if_up failed (%d)\n", ret));
        return;
    }
    IF_RF24ETHERNET_DEBUG_CLIENT(printk("NET: iface up\n"));
 
    ethLocalIP = ip;
    //printk("%s\n",localIP().toString().c_str());
    _dnsServerAddress = dns;
    isInitialized = true;
    RF24Client::serverConnectionTimeout = 30000;
 
#endif
}
 
/*******************************************************/
 
void RF24EthernetClass::set_gateway(IPAddress gwIP)
{
#if USE_LWIP < 1
    uip_ipaddr_t ipaddr;
    uip_ip_addr(ipaddr, gwIP);
    uip_setdraddr(ipaddr);
#elif USE_LWIP == 1
    ip4_addr_t new_gw;
    IP4_ADDR(&new_gw, gwIP[0], gwIP[1], gwIP[2], gwIP[3]);
    #if defined RF24ETHERNET_CORE_REQUIRES_LOCKING
    if (useCoreLocking) {
        ETHERNET_APPLY_LOCK();
    }
    #endif
    netif_set_gw(&Ethernet.myNetif, &new_gw);
    #if defined RF24ETHERNET_CORE_REQUIRES_LOCKING
    if (useCoreLocking) {
        ETHERNET_REMOVE_LOCK();
    }
    #endif
#elif USE_LWIP == 2
 
    struct net_if* iface = rf24_netif_get_iface();
    if (iface == NULL) {
        IF_RF24ETHERNET_DEBUG_CLIENT(printk("NET: Set GW: no default iface\n"));
        return;
    }
    struct in_addr gate;
    gate.s_addr = gwIP;
    net_if_ipv4_set_gw(iface, &gate);
 
#endif
}
 
/*******************************************************/
 
void RF24EthernetClass::listen(uint16_t port)
{
#if USE_LWIP < 1
    uip_listen(HTONS(port));
#elif USE_LWIP == 1
 
    #if defined RF24ETHERNET_CORE_REQUIRES_LOCKING
    if (useCoreLocking) {
        ETHERNET_APPLY_LOCK();
    }
    #endif
    RF24Client::myPcb = tcp_new();
    tcp_err(RF24Client::myPcb, RF24Client::error_callback);
 
    err_t err = tcp_bind(RF24Client::myPcb, IP_ADDR_ANY, port);
    if (err != ERR_OK) {
        IF_RF24ETHERNET_DEBUG_CLIENT(Serial.println("Server: Unable to bind to port"););
    }
 
    RF24Client::gState[0]->connected = false;
    RF24Client::gState[0]->result = 0;
 
    RF24Client::myPcb = tcp_listen(RF24Client::myPcb);
 
    tcp_arg(RF24Client::myPcb, &RF24Client::gState[0]);
    tcp_accept(RF24Client::myPcb, RF24Client::accept);
 
    #if defined RF24ETHERNET_CORE_REQUIRES_LOCKING
    if (useCoreLocking) {
        ETHERNET_REMOVE_LOCK();
    }
    #endif
#else
 
#endif
}
 
/*******************************************************/
 
IPAddress RF24EthernetClass::localIP()
{
#if USE_LWIP < 1
    uip_ipaddr_t a;
    uip_gethostaddr(a);
    return ip_addr_uip(a);
#elif USE_LWIP == 1
    if (netif_is_up(&myNetif)) {
        // Get the IP address structure
        const ip4_addr_t* ip_addr = netif_ip4_addr(&myNetif);
        return (IPAddress(ip_addr->addr));
    }
#elif USE_LWIP == 2
 
    return ethLocalIP;
 
#endif
    return IPAddress {0, 0, 0, 0};
}
 
/*******************************************************/
 
IPAddress RF24EthernetClass::subnetMask()
{
#if USE_LWIP < 1
    uip_ipaddr_t a;
    uip_getnetmask(a);
    return ip_addr_uip(a);
#elif USE_LWIP == 1
    if (netif_is_up(&myNetif)) {
        // Get the IP address structure
        const ip4_addr_t* ip_addr = netif_ip4_netmask(&myNetif);
        return (IPAddress(ip_addr->addr));
    }
    return IPAddress {0, 0, 0, 0};
#elif USE_LWIP == 2
 
    struct net_if* iface = rf24_netif_get_iface();
    if (iface == NULL) {
        IF_RF24ETHERNET_DEBUG_CLIENT(printk("NET: Set GW: no default iface\n"));
        return IPAddress {0, 0, 0, 0};
    }
 
    struct in_addr my_ip;
    my_ip.s_addr = localIP();
    struct in_addr mask = net_if_ipv4_get_netmask_by_addr(iface, &my_ip);
    return mask.s_addr;
 
#endif
}
 
/*******************************************************/
 
IPAddress RF24EthernetClass::gatewayIP()
{
#if USE_LWIP < 1
    uip_ipaddr_t a;
    uip_getdraddr(a);
    return ip_addr_uip(a);
#elif USE_LWIP == 1
    if (netif_is_up(&myNetif)) {
        // Get the IP address structure
        const ip4_addr_t* ip_addr = netif_ip4_gw(&myNetif);
        return (IPAddress(ip_addr->addr));
    }
    return IPAddress {0, 0, 0, 0};
#elif USE_LWIP == 2
    struct net_if* iface = rf24_netif_get_iface();
    if (iface == NULL) {
        IF_RF24ETHERNET_DEBUG_CLIENT(printk("NET: Set GW: no default iface\n"));
        return IPAddress {0, 0, 0, 0};
    }
 
    return net_if_ipv4_get_gw(iface).s_addr;
 
#endif
}
 
/*******************************************************/
 
IPAddress RF24EthernetClass::dnsServerIP()
{
    return _dnsServerAddress;
}
 
/*******************************************************/
#if USE_LWIP == 1
//Should be call inside PHY RX Ethernet IRQ
void RF24EthernetClass::EthRX_Handler(const uint8_t* ethFrame, const uint16_t lenEthFrame)
{
    LINK_STATS_INC(link.recv);
    MIB2_STATS_NETIF_ADD(&Ethernet.myNetif, ifinoctets, lenEthFrame);
    if (Ethernet.isUnicast(ethFrame[0]))
    {
        MIB2_STATS_NETIF_INC(&Ethernet.myNetif, ifinucastpkts);
    }
    else
    {
        MIB2_STATS_NETIF_INC(&Ethernet.myNetif, ifinnucastpkts);
    }
 
    writeRXQueue(&RXQueue, ethFrame, lenEthFrame);
}
 
#endif
 
/*******************************************************/
 
void RF24EthernetClass::tick()
{
 
#if defined __ZEPHYR__
    k_msleep(1);
#elif defined ARDUINO_ARCH_ESP32
    const TickType_t xDelay = pdMS_TO_TICKS(1);
    vTaskDelay(xDelay);
#elif defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_NRF52) || defined ARDUINO_ARCH_RP2350 || defined ARDUINO_NRF54L15
    yield();
#endif
 
#if USE_LWIP < 1
    uint8_t result = RF24Ethernet.mesh.update();
 
    if (Ethernet.mesh.mesh_address == 0) {
        Ethernet.mesh.DHCP();
    }
 
    if (result == EXTERNAL_DATA_TYPE) {
        if (RF24Ethernet.network.frag_ptr->message_size <= UIP_BUFSIZE && RF24Ethernet.network.frag_ptr->message_size >= 28) {
            uip_len = RF24Ethernet.network.frag_ptr->message_size;
        }
    }
    else if (result == NETWORK_CORRUPTION) {
        RF24Ethernet.networkCorruption++;
    }
 
    #if !defined(RF24_TAP)
    if (uip_len > 0) {
        uip_input();
        if (uip_len > 0) {
            network_send();
        }
    }
    else if (timer_expired(&Ethernet.periodic_timer)) {
        timer_reset(&Ethernet.periodic_timer);
        for (int i = 0; i < UIP_CONNS; i++) {
            uip_periodic(i);
            /* If the above function invocation resulted in data that
            should be sent out on the network, the global variable
            uip_len is set to a value > 0. */
            if (uip_len > 0) {
                network_send();
            }
        }
    }
    #else  // defined (RF24_TAP)
    if (uip_len > 0) {
        if (BUF->type == htons(UIP_ETHTYPE_IP)) {
            uip_arp_ipin();
            uip_input();
            /* If the above function invocation resulted in data that
            should be sent out on the network, the global variable
            uip_len is set to a value > 0. */
            if (uip_len > 0) {
                uip_arp_out();
                network_send();
            }
        }
        else if (BUF->type == htons(UIP_ETHTYPE_ARP)) {
            uip_arp_arpin();
            /* If the above function invocation resulted in data that
            should be sent out on the network, the global variable
            uip_len is set to a value > 0. */
            if (uip_len > 0) {
                network_send();
            }
        }
    }
    else if (timer_expired(&Ethernet.periodic_timer)) {
        timer_reset(&Ethernet.periodic_timer);
        for (int i = 0; i < UIP_CONNS; i++) {
            uip_periodic(i);
            /* If the above function invocation resulted in data that
            should be sent out on the network, the global variable
            uip_len is set to a value > 0. */
            if (uip_len > 0) {
                uip_arp_out();
                network_send();
            }
        }
    #endif // defined (RF24_TAP)
    #if UIP_UDP
    for (int i = 0; i < UIP_UDP_CONNS; i++) {
        uip_udp_periodic(i);
        /* If the above function invocation resulted in data that
            should be sent out on the network, the global variable
            uip_len is set to a value > 0. */
        if (uip_len > 0) {
            // uip_arp_out();
            // network_send();
            RF24UDP::_send((uip_udp_userdata_t*)(uip_udp_conns[i].appstate));
        }
    }
    #endif /* UIP_UDP */
    #if defined(RF24_TAP)
    /* Call the ARP timer function every 10 seconds. */
 
    if (timer_expired(&Ethernet.arp_timer)) {
        timer_reset(&Ethernet.arp_timer);
        uip_arp_timer();
    }
}
    #endif // RF24_TAP
 
#elif USE_LWIP == 1 // Using LWIP
 
    uint8_t result = RF24Ethernet.mesh.update();
 
    if (Ethernet.mesh.mesh_address == 0) {
        Ethernet.mesh.DHCP();
    }
 
    if (result == EXTERNAL_DATA_TYPE) {
        uint16_t len = RF24Ethernet.network.frag_ptr->message_size;
        if (len > 28) {
            memcpy(networkBuffer, RF24Ethernet.network.frag_ptr->message_buffer, len);
            Ethernet.EthRX_Handler(networkBuffer, len);
            IF_ETH_DEBUG_L1(Serial.println("Net: In"););
        }
    }
 
    #if defined RF24ETHERNET_CORE_REQUIRES_LOCKING
    if (useCoreLocking) {
        ETHERNET_APPLY_LOCK();
    }
    #endif
    sys_check_timeouts();
 
    #if defined RF24ETHERNET_CORE_REQUIRES_LOCKING
    if (useCoreLocking) {
        ETHERNET_REMOVE_LOCK();
    }
    #endif
 
    pbuf* p = readRXQueue(&RXQueue);
    if (p != nullptr)
    {
 
    #if defined RF24ETHERNET_CORE_REQUIRES_LOCKING
        if (useCoreLocking) {
            ETHERNET_APPLY_LOCK();
        }
    #endif
        if (myNetif.input(p, &myNetif) != ERR_OK)
        {
            LWIP_DEBUGF(NETIF_DEBUG, ("IP input error\r\n"));
            if (p != nullptr) {
                pbuf_free(p);
                p = NULL;
            }
        }
 
    #if defined RF24ETHERNET_CORE_REQUIRES_LOCKING
        if (useCoreLocking) {
            ETHERNET_REMOVE_LOCK();
        }
    #endif
    }
    sendQueuedFrame();
 
#elif USE_LWIP == 2
 
    uint8_t result = RF24Ethernet.mesh.update();
 
    if (Ethernet.mesh.mesh_address == 0) {
        Ethernet.mesh.DHCP();
    }
 
    if (result == EXTERNAL_DATA_TYPE) {
        const uint16_t len = RF24Ethernet.network.frag_ptr->message_size;
        if (len == 0 || len > MAX_PAYLOAD_SIZE) {
            return;
        }
        uint8_t* buf = RF24Ethernet.network.frag_ptr->message_buffer;
        rf24_netif_deliver_frame(RF24Ethernet.network.frag_ptr->message_buffer, RF24Ethernet.network.frag_ptr->message_size);
    }
 
#endif
}
 
/*******************************************************/
 
void RF24EthernetClass::network_send()
{
 
#if USE_LWIP < 1
    IPAddress gwIP = Ethernet.gatewayIP();
    int16_t nodeAddress = 0;
 
    //If not the master node
    if (Ethernet.mesh.mesh_address != 0) {
        if (gwIP[3] != uip_buf[19]) { // If not sending to the gateway
            IPAddress local_ip = Ethernet.localIP();
            if (local_ip[0] == uip_buf[16] && local_ip[1] == uip_buf[17]) { // If we are local within the nRF24 network
                //Request an address lookup from the Master node
                nodeAddress = Ethernet.mesh.getAddress((char)uip_buf[19]); // Do an address lookup
                if (nodeAddress < 0) {
                    nodeAddress = 0; // If the result is negative, send to master
                }
            } // If this address is outside the nRF24 network, it will be send to master (00)
        }
    }
    else {
        IPAddress local_ip = Ethernet.localIP();
        if (local_ip[0] == uip_buf[16] && local_ip[1] == uip_buf[17]) { // If within the nRF24 radio network, do a lookup, else send to self (00)
            nodeAddress = Ethernet.mesh.getAddress((char)uip_buf[19]);
            if (nodeAddress < 0) {
                return;
            }
        }
    }
    RF24NetworkHeader headerOut(nodeAddress, EXTERNAL_DATA_TYPE);
 
    #if defined ETH_DEBUG_L1 || defined ETH_DEBUG_L2
    bool ok = RF24Ethernet.network.write(headerOut, uip_buf, uip_len);
    if (!ok) {
        Serial.println();
        Serial.print(millis());
        Serial.println(F(" *** RF24Ethernet Network Write Fail ***"));
    }
    #else
        RF24Ethernet.network.write(headerOut, uip_buf, uip_len);
    #endif
 
    #if defined ETH_DEBUG_L2
    if (ok) {
        Serial.println();
        Serial.print(millis());
        Serial.println(F(" RF24Ethernet Network Write OK"));
    }
    #endif
#else
 
#endif
}
 
/*******************************************************/
#if USE_LWIP == 2
int RF24EthernetClass::sendFrame(const uint8_t* data, size_t len)
{
    IF_RF24ETHERNET_DEBUG_CLIENT(printk("Net out\n"));
 
    if (!data || !len || !isInitialized) {
        return -EINVAL;
    }
 
    IPAddress gwIP = Ethernet.gatewayIP();
 
    int16_t nodeAddress = 0;
    const uint8_t* buf = data;
    //If not the master node
    if (Ethernet.mesh.mesh_address != 0) {
        if (gwIP[3] != buf[19]) { // If not sending to the gateway
            IPAddress local_ip = Ethernet.localIP();
            if (local_ip[0] == buf[16] && local_ip[1] == buf[17]) { // If we are local within the nRF24 network
                //Request an address lookup from the Master node
                nodeAddress = Ethernet.mesh.getAddress((char)buf[19]); // Do an address lookup
                if (nodeAddress < 0) {
                    nodeAddress = 0; // If the result is negative, send to master
                }
            } // If this address is outside the nRF24 network, it will be send to master (00)
        }
    }
    else {
        IPAddress local_ip = Ethernet.localIP();
 
        if (local_ip[0] == buf[16] && local_ip[1] == buf[17]) { // If within the nRF24 radio network, do a lookup, else send to self (00)
            nodeAddress = Ethernet.mesh.getAddress((char)buf[19]);
            if (nodeAddress < 0) {
                return 0;
            }
        }
    }
 
    memcpy(outputBuffer, data, len);
    RF24NetworkHeader headerOut(nodeAddress, EXTERNAL_DATA_TYPE);
    bool ok = RF24Ethernet.network.write(headerOut, outputBuffer, len);
    IF_RF24ETHERNET_DEBUG_CLIENT(printk("Net out ok:%d len=%zu\n", ok, len));
    return 0; //ok ? 0 : -EIO;
}
#endif
/*******************************************************/